Collaborative Widget State Synchronization

Abstract

A computing system receives location data from each of a plurality of user computing devices, the location data indicating a cursor position on a collaborative user interface for each collaborator in a collaborative session. The system determines whether the cursor position of each collaborator is within a bounding area of ​​a widget presented on the collaborative user interface based on the location data. When the cursor position of each collaborator is within the bounding area of ​​the widget, the system transmits feedback response data to each of the plurality of user computing devices to cause a corresponding feedback response for the widget to be presented on the collaborative user interface displayed on each of the plurality of user computing devices.

Description

[Technical field]

[0001] This application claims the benefit of priority to each of (i) U.S. patent application Ser. No. 18 / 121,520, filed March 14, 2023, and (ii) Provisional U.S. patent application Ser. No. 63 / 320,634, filed March 16, 2022, the above-mentioned priority applications being incorporated by reference herein in their entireties.

[0002] The examples described herein relate to providing an integrated application platform and collaborative tools for implementing widgets. [Background technology]

[0003] Software design tools have many forms and applications. In the area of ​​application user interfaces, for example, software design tools require designers to reconcile functional aspects of a program with aesthetic and even legal requirements, resulting in a collection of pages that form the application's user interface. Widgets on an application's user interface may comprise buttons, scrolling features, hover-over elements, and other selectable objects on the user interface that enable user interaction with the user interface and collectively result in the user experience. [Brief description of the drawings]

[0004] [Figure 1] FIG. 1 illustrates a networked computer system implementing an interactive and collaborative graphic design application platform on multiple user computing devices, according to one or more illustrative examples. [Diagram 2] A diagram illustrating an example method for tracking cursor position and input and propagating feedback responses to collaborator computing devices according to one or more embodiments. [Figure 3A]FIG. 13 illustrates an exemplary real-time feedback response propagated to each user computing device for a widget presented on a multi-user canvas, according to one or more embodiments. [Figure 3B] FIG. 13 illustrates an exemplary real-time feedback response propagated to each user computing device for a widget presented on a multi-user canvas, according to one or more embodiments. [Figure 3C] FIG. 13 illustrates an exemplary real-time feedback response propagated to each user computing device for a widget presented on a multi-user canvas, according to one or more embodiments. [Figure 4] FIG. 1 illustrates a computer system upon which one or more embodiments described herein may be implemented. [Diagram 5] FIG. 1 illustrates a user computing device for use in connection with various examples described herein. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0005] An example includes a computing system operable to implement an interactive collaborative application platform (ICAP) to enable real-time collaboration by users on one or more media. According to an example, a computing device can operate one or more application services of the ICAP to selectively render one or more interactive elements. As described with the example, the interactive elements can include widgets, which include interactive objects implemented by discrete logic (e.g., third-party code). Interactive objects, such as those provided by widgets, can be executed and rendered on a collaborative medium or user interface of an application service. The described example further provides widget objects to be persistent and dynamically responsive to different types of user inputs using functionality provided with widgets.

[0006] According to an example, a networked computer system operates to enable a plurality of user computing devices to utilize any one of a plurality of collaborative application services to create and update content that is rendered on a collaborative medium or user interface. As a collaborative environment, the networked computer system detects changes to a canvas provided with user-generated content (e.g., UI designs) created by one or more collaborators. In some examples, the user-generated content elements may be the result of user interaction with a suite of interactive tools provided with or in association with the canvas. Additionally, the canvas and content elements may be rendered on multiple computing devices of the collaborators. Additionally, the content elements rendered on the canvas may include widgets. For example, the widgets may be retrieved and executed to generate interactive objects, and each collaborator may interact with the interactive objects to trigger the widget's functionality. The networked computer system then propagates the detected changes in real time (or near real time) to a workspace file corresponding to the collaborative medium or user interface. In real time, updates to the workspace file are sent to each computing device of the collaborators to provide a real-time collaborative experience.

[0007] In some instances, a networked computer system is provided that includes a memory resource that stores a set of instructions, and one or more processors are operable to communicate the set of instructions to a plurality of user devices. The set of instructions may be communicated to a user computing device in association with the user computing device being operated to render content for a particular application service on a collaborative medium. In an instance, the content rendered using the collaborative medium may be edited by a user input indicating any one of a plurality of different input actions. As illustrated by various instances, the instructions and data communicated to the computing device enable the computing device to select one of a plurality of collaborative application services to access, view, and edit the rendered content on the corresponding collaborative medium.

[0008] Thus, the described examples enable users of an application service to interact with interactive elements, such as widgets, in a manner that generates visual feedback on a collaborative medium, which is rendered on the computing devices of the other collaborators. For example, some type of input, such as a preselection input (e.g., cursor hover), can cause the interactive element to change visual state or generate other visual feedback. As described by the examples, the visual feedback generated by such input can be transmitted in real time to the computing devices of the other collaborators, such that the collaborative media of all users show the same object generating corresponding visual feedback (e.g., highlighting or other visual change in response to the preselection input). In this way, the state and / or appearance of an interactive element, such as a widget, can be accurately reflected on the collaborative media of each computing device.

[0009] According to various implementations described herein, the networked computer system and / or each of the user computing devices tracks cursor movements and inputs on the collaborative medium by each of the collaborators and provides visual feedback based on the location of each of the cursors and inputs provided by each of the collaborators. In one example, when a collaborator provides input to create a widget (e.g., an interactive element on a given UI), the networked computer system can establish a bounding area that encompasses the widget (e.g., tracing the borders of the widget) and generate feedback about future interaction states on the widget (e.g., hover-over, selection, focus, click, and any other user action pseudo-class). Thereafter, when any one of the collaborators interacts with the widget, the networked computer system propagates real-time specified feedback responses to all other collaborators.

[0010] In some instances, the networked computer system may provide an application programming interface (API) that allows collaborators to set and modify feedback response properties of a given widget's sublayer, such as widget fill (e.g., transparency level, color, etc.), stroke width (feedback border width), stroke color, and emphasis or text styling characteristics (e.g., resize, underline, bold, or italics). When the feedback response properties are configured, the networked computer system may monitor input and cursor position on the collaborative medium for each of the collaborators and provide a feedback response(s) to each of the collaborators when such input is performed on the widget and when the cursor position is located within the widget's bounding area.

[0011] As an example, during a collaborative session between multiple remote collaborators, a collaborative medium may be presented on each of the collaborators' computing devices. The collaborative medium may be presented with any number of widgets. In some variations, each widget may have its own feedback response configuration (e.g., configured by one or more of the collaborators) or some or all of the widgets may have a common feedback response configuration (e.g., a default configuration established by the network computer system). Any user action (e.g., a hover-over action, a focus action, an activation action, etc.) performed on a widget by a collaborator may trigger a specific feedback response that the network computer system propagates in real time to the collaborative medium displayed on each computing device of each collaborator. As a technical effect, feedback responses for a given widget presented to all collaborators in real time may provide contextual information to all collaborators based on cursor position and user input. It is contemplated that the propagation of widget feedback responses to all collaborators may provide greater interactivity between collaborators and improve the user experience.

[0012] One or more embodiments described herein enable methods, techniques, and actions performed by a computing device to be implemented programmatically, or as computer-implemented methods. As used herein, programmatically means through the use of code or computer-executable instructions. These instructions may be stored in one or more memory resources of a computing device. Programmatically implemented steps may or may not be automated.

[0013] One or more embodiments described herein may be implemented using programmatic modules, engines, or components. A programmatic module, engine, or component may include a program, a subroutine, a portion of a program, or a software or hardware component capable of performing one or more described tasks or functions. As used herein, a module or component may exist on a hardware component independent of other modules or components. Alternatively, a module or component may be a shared element or process of other modules, programs, or machines.

[0014] Some embodiments described herein may require the use of a computing device, including, in general, processing and memory resources. For example, one or more embodiments described herein may be implemented, in whole or in part, on a computing device, such as a server, a desktop computer, a cellular or smartphone, a tablet, a wearable electronic device, a laptop computer, a printer, a digital picture frame, network equipment (e.g., a router), and a tablet device. The memory resources, processing resources, and network resources may all be used in connection with establishing, using, or implementing any embodiment described herein (including in connection with implementing any method or in connection with implementing any system).

[0015] Additionally, one or more of the embodiments described herein may be implemented through the use of instructions executable by one or more processors. These instructions may be carried on a computer-readable medium. The machines illustrated or described below with respect to the figures provide examples of processing resources and computer-readable media on which instructions for implementing embodiments of the invention may be carried and / or executed. In particular, many of the machines illustrated with embodiments of the invention include a processor(s) and various forms of memory for storing data and instructions. Examples of computer-readable media include persistent memory storage devices, such as hard drives on a personal computer or server. Other examples of computer storage media include portable storage units, such as CD or DVD units, flash memory (such as carried on a smartphone, multifunction device, or tablet), and magnetic memory. Computers, terminals, and network-enabled devices (e.g., mobile devices such as smartphones and tablet computers) are all examples of machines and devices that utilize processors, memory, and instructions stored on a computer-readable medium. Additionally, the embodiments may be implemented in the form of a computer program, or a computer usable carrier medium capable of carrying such a program.

[0016] System Description FIG. 1 illustrates a networked computer system 150 for implementing an interactive and collaborative application platform on multiple user computing devices 10, 12, according to one or more examples. As described with one example of FIG. 1, the networked computing system 150 may be implemented using one or more servers that communicate with the user computing devices 10, 12 over one or more networks. In an example, the networked computing system 150 performs operations to enable an interactive and collaborative application platform ("ICAP 100") to be implemented on the user computing devices 10, 12. In an example, the ICAP 100 enables the user's computing devices 10, 12 to utilize one or more different application services, each of which provides collaborative application functionality for a shared application medium (e.g., a canvas). In one example, the ICAP 100 provides application services to enable collaborators to create dynamic and interactive designs, including designs that can be prototyped or imported into a runtime environment. Additionally or alternatively, the ICAP may include a whiteboarding application service to enable collaborators to create visual content for the purposes of sharing ideas and communicating about goals. Thus, each application service provided through the ICAP 100 may provide functionality and configuration that is distinct from other application services.

[0017] By way of illustration, the ICAP 100 may be implemented on any number of user computing devices 10, 12 in a concurrent manner to enable individual collaborators to utilize one of a number of application services in a collaborative environment. Each application service may include resources and instructions to enable a collaborator to access, update, and / or create a corresponding workspace file. In particular, the ICAP 100 may generate a collaborative media 102 in which the workspace file is rendered.

[0018] In a further example, the ICAP 100 runs on each user computing device 10, 12 as a multi-mode web-based platform, with each mode implementing one of a number of application services provided through the network computing system 150. The ICAP 100 can operate in any of a number of modes to render and update workspace files on a collaborative medium using the application services of the mode in use.

[0019] According to an example, a user of each computing device 10, 12 operates a web-based application 80 to access a network site where programmatic resources are retrieved and executed to implement the ICAP 100. The web-based application 80 may execute scripts, code, and / or other logic to implement the functionality of the ICAP 100. In an example, the web-based application 80 may correspond to a commercially available browser such as GOOGLE CHROME (developed by GOOGLE, INC.), SAFARI (developed by APPLE, INC.), INTERNET EXPLORER (developed by MICROSOFT CORPORATION), etc. In such an example, the ICAP 100 processes may be implemented as scripts and / or other embedded code that the web-based application 80 downloads from the network site. For example, the web-based application 80 may execute code embedded within a web page to implement the ICAP 100 processes. Web-based application 80 may also execute those scripts and retrieve other scripts and programmatic resources (e.g., libraries) from network sites and / or other local or remote locations. Illustratively, Web-based application 80 may execute JAVASCRIPT® embedded in HTML resources (e.g., Web pages structured according to HTML 5.0 or other versions provided under standards published by the W3C or WHATWG consortium).In some instances, the rendering engine 120 running on each user computing device 10, 12 may utilize GPU accelerated logic, such as that provided through a WebGL (Web Graphics Library) program that executes a Graphics Library Shader Language (GLSL) program running on a graphics processing unit (GPU).

[0020] ICAP 100 may be implemented as part of a network service where web-based application 80 communicates with one or more remote computers (e.g., servers used for network services) to execute processes of ICAP 100. Web-based application 80 retrieves some or all of the programmatic resources for implementing ICAP 100 from a network site. Web-based application 80 may also access various types of data sets in providing ICAP 100. The data sets may correspond to files, design libraries (e.g., pre-designed design elements), and programmatic resources that may be stored remotely (e.g., in association with an account, on a server) or locally. In an illustrative example, network computer system 150 provides a shared resource library that user computing devices 10, 12 may use with any application service. In this manner, a user may initiate a session to implement ICAP 100 for the purpose of creating or editing a workspace file to be rendered on collaborative medium 102 according to one of the application services of ICAP 100.

[0021] In an illustrative example, the ICAP 100 includes a programmatic interface 112 and a collaborative media 102 that allows collaborators to interact with and make changes to, for example, a current document, an interactive design, a whiteboard, or other type of collaborative media. The ICAP 100 may further include a rendering engine 120 that makes changes to the collaborative media 102. The programmatic interface 112 may include one or more processes that execute to access and retrieve programmatic resources from local and / or remote sources. In one implementation, the programmatic interface 112 may generate the collaborative media 102 (e.g., an HTML 5.0 canvas) using programmatic resources associated with a web-based application 80. Additionally or as a variation, the programmatic interface 112 may trigger or otherwise cause the collaborative media 102 to be generated using programmatic resources and data sets retrieved from a local source (e.g., memory) or a remote source (e.g., from a network service).

[0022] The programmatic interface 112 may also retrieve programmatic resources, including an application framework, for use with the collaborative medium 102. The application framework may include a data set that defines or configures a set of interactive graphical tools that integrate with the collaborative medium 102 and provide an input interface to enable a user to provide input for creating, editing, and interacting with a particular design (e.g., a UI design interface or a whiteboard design).

[0023] According to some examples, the input interface may be implemented as a functional layer integrated with the collaborative medium 102 to detect and interpret user input. The input interface may use references to the collaborative medium 102 to dynamically determine the user's cursor position and identify the screen location of the user input (e.g., click input). Additionally, the input interface may interpret the user's input actions based on the location of the detected input (e.g., whether the location of the input indicates a selection of a tool, an object rendered on the collaborative medium 102, or an area of ​​the collaborative medium 102), the frequency of the detected input (e.g., double click) in a given time period, and / or the start and end locations of an input or series of inputs (e.g., start and end locations of a click-and-drag input), as well as various other input types (e.g., right click, screen tap, etc.) that the user may specify through one or more input devices. In this manner, the input interface may interpret a series of inputs as design tool selections (e.g., shape selection based on the location of the input) as well as inputs to define attributes (e.g., dimensions) of the selected shape. In an example, different types of input that may be received can include interactive input that generates visual feedback, such as a pre-selection input that generates a visual state change of a corresponding widget.

[0024] In some instances, the ICAP 100 includes instructions that enable the user computing device 10, 12 to utilize multiple application services at once in connection with the user computing device 10, 12 accessing, updating, and / or creating workspace files on a collaborative medium. In an instance, each workspace file may be associated with a particular application service, and by default, a computing device that opens a workspace file utilizes the default application service to access and update the workspace file. A user may also switch modes on the ICAP 100 to utilize a different application service to update the workspace file.

[0025] The network computing system 150 may include a site manager 158 for managing a website in which a set of web resources 155 (e.g., web pages) are made available for web-based applications 80 executed by the user computing devices 10, 12. The web resources 155 may include instructions, such as scripts or other logic ("ICAP instructions 157"), that are executable by a browser or web component of the user computing device 10, 12. The web resources 155 may also include (i) shared resources provided to the user computing device 10, 12 in connection with the user computing device 10, 12 utilizing any of the application services, and (ii) application-specific resources that execute on the user computing device 10, 12 for particular ones of the available application services. In some instances, the web resources 155 include a shared library of user-interactive elements that allow a user to select certain elements for use on the collaborative medium 102 associated with the application services.

[0026] In some variations, when the computing device 10, 12 accesses and downloads the web resource 155, the web-based application 80 executes the ICAP instructions 157 to implement the functionality as described with respect to the examples herein. For example, the ICAP instructions 157 may be executed by the web-based application 80 to start the program interface 112 on the user computing device 10. The start-up of the program interface 112 may coincide with the establishment of a web socket connection between the program interface 112 and a service component 160 of the network computing system 150.

[0027] In some instances, the web resources 155 include logic that the web-based application 80 executes to initiate one or more processes of the program interface 112, causing the ICAP 100 to retrieve additional programmatic resources and data sets to implement the functionality as described by the examples herein. The web resources 155 can embed logic (e.g., JAVASCRIPT® code), including GPU accelerated logic, in an HTML page for download by a collaborator's computing device 10, 12. The program interface 112 can be triggered to retrieve additional programmatic resources and data sets from the network service 152 and / or from local resources of the computing device 10, 12 to implement each of the multiple applications of the ICAP 100. For example, some of the components of the ICAP 100 can be implemented through web pages that can be downloaded onto the computing device 10, 12 after authentication is performed and / or when the user performs additional actions (e.g., downloading one or more pages of a workspace). Thus, in the illustrated example, the network computing system 150 can communicate the ICAP instructions 157 to the computing devices 10, 12 through a combination of network communications, including through the download activity of the Web-based application 80, where the ICAP instructions 157 are received and executed by the Web-based application 80.

[0028] Using the web-based application 80, the computing device 10, 12 may access the website of the network service 152 to download web pages or web resources. Upon accessing the website, the web-based application 80 may communicate an account identifier to the service component 160 automatically (e.g., through stored credentials) or through manual entry. In some instances, the web-based application 80 may also communicate one or more additional identifiers that correlate to the particular collaborator's user identifier.

[0029] Further, in some instances, the service component 160 may use a particular collaborator's user or account identifier to retrieve profile information 109 from a user profile store 167 of the network computing system 150. Additionally or as a variation, profile information 109 for a user may be determined and stored locally on the user's computing device 10, 12.

[0030] The service component 160 may also retrieve from a file store 164 of the network computing system 150 an active workspace file ("active workspace file 163") linked to a collaborator's user account or identifier. The profile store 167 may also identify workspaces identified by accounts and / or users, and the file store 164 may store a data set comprising the workspace. The data set stored by the file store 164 may include, for example, workspace pages and one or more data structure representations 161 rendered by the rendering engine 120 from each active workspace file 163. Additionally or as a variation, each file 163 may be associated with metadata identifying the application used to create and / or render the particular file 163.

[0031] Further, in an illustrative example, the service component 160 provides to the web-based application 80 a representation of a workspace associated with a user, which representation identifies individual files associated with the user and / or user account. The workspace representation may also identify a set of files, each file including one or more pages, and each page including objects that are part of the collaborative medium 102.

[0032] On the user computing devices 10, 12, the collaborators can view the workspace representation through a web-based application 80, and the collaborators can choose to open workspace files 163 through the web-based application 80. In an illustrative example, when a collaborator chooses to open one of the active workspace files 163, the web-based application 80 launches a multi-user canvas 102. For example, the ICAP 100 can launch an HTML 5.0 canvas as a component of the web-based application 80, and the rendering engine 120 can access one or more data structure representations 111 of the UI interface to render the selected workspace file on the collaborative medium 102.

[0033] In an illustrative example, the ICAP 100 may be implemented to execute in multiple operating modes, each mode corresponding to one of the application services provided by the network computer system 150. The program interface 112 may also include alternative operating modes. For example, the application framework and input interface for the collaborative medium 102 may differ in form, functionality, or configuration between alternative modes of the ICAP 100. The set of interactive tools provided by the program interface 112 may differ based on the application service with which the workspace file is associated. Furthermore, the type of action that a user or collaborator may perform to register input may vary based on the alternative mode of the program interface 112. Still further, the different modes of the program interface 112 may include different input or user interface features that a user may select and use for inclusion on the collaborative medium 102. By way of illustration, when the ICAP 100 is operating in a mode for a whiteboarding design services application, the program interface 112 may provide an input feature to enable a user to select a design element that is in the form of a "sticky note," whereas in an alternate mode for an interactive graphic design services application, the "sticky note feature" is not available. However, in the alternate mode, the user may be able to select any one of a number of possible shapes or previously designed objects onto which the user can write a text message for display on the collaborative medium 102.

[0034] Still further, the rendering engine 120 may include logic to enable alternative behaviors for different modes of operation based on the design service application that is in use. Illustratively, the rendering engine 120 may implement mode-specific logic to vary the behavior of selected objects, the manner in which objects may be resized or moved, as well as the manner in which objects are rendered on the collaborative medium 102, based on the mode of operation.

[0035] Widgets and interactive elements

[0036] Further, each of the application services may utilize a shared library of interactive elements, as well as core functionality that allows interactive elements to be shared and updated among different application services available through the platform. Furthermore, file types (e.g., workspace files) created and edited using one application service may be utilized with other application services. Moreover, transitions between application services may be seamless, for example, a user computing device 10, 12 may open a workspace file 163 using a first application service (e.g., an interactive graphics application service for UIX design) and then seamlessly switch to using a second application service (e.g., a whiteboarding application service) with the same workspace file 163 without closing the workspace file 163. In such an instance, each application service may allow a user to update the workspace file 163 even while the workspace file 163 is in use in a collaborative environment, as shown in FIG. 1. In such an instance, a user may mode switch the ICAP 100 to switch the application services used with the workspace file 163.

[0037] In an illustrative example, the ICAP 100 is operable on a user computing device 10, 12 to selectively implement a widget with one or more application services. The ICAP 100 may include a widget runtime component 180 that executes as part of the rendering engine 120 to implement the selected widget on the computing device 10, 12. As provided herein, a widget may include a program or combination of programs executable to provide functionality that integrates with the ICAP 100 on the user computing device 10, 12. However, although a widget is designed to be integrated with the ICAP 100, the widget may be provided by a third party source separate from the source of the ICAP 100.

[0038] In various instances, a widget may be associated with resources provided by a third party (e.g., a party other than the developer of the ICAP 100). The widget resources may reside on the network computing system 150, such as with a widget library 190. The resources of each widget may include data, scripts, code, and / or other programming, collectively referred to as widget programming logic ("WPL") 182, for implementing the widget on the user computing device 10. For a given widget, the WPL 182 may include transaction and distribution logic that is communicated to the user computing device 10, 12 in response to one or more events (e.g., user interactions) and executed by the widget runtime component 180 of the rendering engine 120 in response to those events. In an instance, the WPL 182 includes logic initially provided by the network computing system 150 to implement the widget and logic embedded in the collaborative medium 102 that is triggerable through user interactions and / or other events that may occur with respect to the collaborative medium 102.

[0039] Thus, the WPL 182 may include separate sets of programming, scripts, and data that are communicated to the user computing device 10, 12 at different times, such as at the initial time the widget is first implemented by the collaborative medium 102 (e.g., canvas) and after each instance that the user interacts with the widget. In some instances, the WPL 182 may be initially communicated to the widget runtime component 180 from the network computer system 150. The WPL 182 may also be copied and stored in a cache or by other local resources, so that in subsequent instances, the widget runtime component 180 retrieves the WPL 182 from the local resources rather than from the network computer system 150. In the context of the various examples described, references to "widget programming logic" or "WPL 182" are intended to include scenarios in which the WPL 182 transmitted or executed in a particular instance represents a portion of the entire executable logic present for a particular widget, the entire executable logic defining the overall functionality of the widget. In the examples described herein, the ICAP 100 implements a widget or a component of a widget when the rendering engine 120 executes the WPL 182 for the widget.

[0040] According to various implementations, the network computing system 150 can provide a widget library 190 that allows the ICAP 100 to access a collection of widgets for use in designing a particular UI. For example, the widget library 190 can be provided as part of the network service 152 in the form of a widget marketplace or collection where a user can search for and select individual widgets for use with the collaborative medium 102. In such an implementation, the widgets can be selectively executed by the ICAP 100 to provide interactive features to the collaborative medium 102 that are persistent, for example. A user can search or otherwise interact with the widget library 190 to select a particular widget. For example, a user can conduct a search of the widget library 190 to identify a selected widget. In variations, the widgets can be provided from a third-party site or resource. Still further, in some variations, the program interface 112 can access an online widget store or network database to enable the user computing device 10, 12 to access and use the widgets.

[0041] The widget library 190 may include the WPL 182 for any one of a number of widgets available to the user computing device 10, 12. In a variation, the widget library 190 may include a reference or pointer to the WPL 182 and / or other resources for a given widget. The widget runtime component 180 may then use the pointer to retrieve the WPL 182 from other network sources.

[0042] Each user of the computing device 10, 12 can select to implement a particular widget on a given collaborative medium 102. When a user selects to launch a particular widget on the collaborative medium 102, a widget handler 166 executes on the network computing system 150 to access the widget resource of the selected widget and sends a WPL 182 corresponding to the selected widget to the ICAP 100 to launch the widget on the collaborative medium 102. A widget runtime component 180 receives and executes the WPL 182 to generate a widget object 185 as part of the provided design on the collaborative medium 102. In this manner, the widget object 185 can overlay a portion of the collaborative medium 102 and form a persistent feature of the workspace file. In an illustrative example, various operations can be performed on the collaborative medium 102 and widget rendering without triggering the use of the WPL 182. For example, the rendering engine 120 can operate to resize or reposition the widget object 185 based on corresponding user input targeted to manipulating the widget object 185 as an object on the collaborative medium 102. As a further illustration, the collaborative medium 102 can contain a widget object 185 that is closed and then opened to render without executing the WPL 182 for the widget. In this manner, the widget object 185 can reside with the collaborative medium 102 as part of an existing design, subject to the rules and logic of the rendering engine 120. However, input targeted to interactive aspects of the widget (e.g., input that triggers a selectable or active feature in the frame of the widget object 185) can trigger execution of widget-specific programming logic that can change the state of the widget object 185.

[0043] In various implementations, the rendering engine 120 includes a widget runtime component 180 for executing the WPL 182 of a selected widget. The widget runtime component 180 operates to selectively execute the WPL 182 for a widget that is launched for use with the collaborative medium 102. Among other tasks, the widget runtime component 180 may operate to detect user input intended to be a widget interaction, retrieve a WPL 182 corresponding to a widget from a network or local resources based on the detected user input, and execute the retrieved WPL 182 to generate and / or modify a widget object 185. In an illustrative example, multiple instances of the widget runtime component 180 may be launched to perform tasks for multiple widgets that are selectively implemented on the collaborative medium 102.

[0044] In some instances, an implemented widget may be associated with a metadata set 184, which identifies a state of the widget object 185. In variations, multiple widget objects or renderings are generated by execution of WPL 182 for a particular widget, and each widget object 185 is associated with a corresponding set of metadata 184 that represents the state of the corresponding widget object 185 or rendering. Still further, in other variations, the state of an implemented widget may reflect the state or result of an action performed by the implemented widget.

[0045] The widget runtime component 180 can detect widget input intended to be interactive with the widget object 185. For example, the widget runtime component 180 can detect input overlaying an interior of a widget object rendered on the collaborative medium 102. The widget runtime component 180 can capture the widget input and retrieve the WPL 182 from the widget handler 166 or from a local source, as described with examples herein. In some examples, the retrieved WPL 182 is based on the widget input. The widget runtime component 180 executes the retrieved WPL 182 to modify the widget object 185 to reflect the user input. Thus, the widget runtime component 180 can operate to retrieve the WPL 182 and execute it in response to a user interaction with the widget object.

[0046] By way of illustration, the widget object 185 may be an interactive object that includes a frame or border, with one or more interactive features provided within the frame. The widget runtime component 180 may further be configured to respond to different types of input, such as a pre-selection input (e.g., hover) or a selection input. Such input may cause the widget object 185 to visually change state. For example, the widget object 185 may be resized, moved, or other attributes may be altered by the rendering engine 120. Additionally, the widget object 185 may be configured to perform a set of actions, or functions that correspond to, for example, the primary function of the widget object 185, in response to other types of user input (e.g., a selection input). In such an example, execution of the WPL 182 may modify the state of the widget object 185, and the metadata set 184 associated with the widget object 185 may be updated to reflect the updated state of the widget object 185.

[0047] As a collaboration platform, the network computing system 150 can communicate with multiple user computing devices 10, 12 over one or more networks to implement the ICAP 100 on each computing device 10, 12. While Figure 1 shows one example of two users utilizing a collaboration network platform, the illustrated example contemplates a network computing system 150 that would enable collaboration on interfaces among a larger group of users.

[0048] In some instances, the user computing devices 10, 12 may be operated by users associated with a common account, with each user computing device 10, 12 implementing a corresponding ICAP 100 to access the same workspace during overlapping sessions with each other. Thus, each of the user computing devices 10, 12 may access the same set of active workspace files 163 simultaneously, and the respective program interfaces 112 of the ICAPs 100 on each user computing device 10, 12 operate to establish a corresponding communication channel (e.g., a web socket connection) with the service component 160.

[0049] The service component 160 can communicate a copy of the active workspace file 163 to each user computing device 10, 12 such that the computing devices 10, 12 simultaneously render the active workspace file 163 on the collaborative medium 102. In some instances, the active workspace file 163 can be associated with a default application service, and each computing device 10, 12 can open the active workspace file 163 using the associated (or default) application service. Each of the computing devices 10, 12 can maintain a local data structure representation 111 of the selected workspace file 163. The service component 160 can also maintain a network-side data structure representation 161 obtained from the active workspace file 163 that matches the local data structure representation 111 on each of the computing devices 10, 12. In some instances, the users of the computing devices 10, 12 can switch the operating mode of the ICAP 100 to view and update the workspace using a non-default application service. Thus, in some variations, the active workspace file 163 may be updated by a user utilizing any of the application services.

[0050] Illustratively, during a collaborative session, users may collaboratively view and edit the workspace file 163 using either the application service or the whiteboarding application service. The network computer system 150 may detect changes made by users utilizing either the application service or the whiteboarding application service, and the network computer system 150 may propagate the detected changes made on any one of the user computing devices 10, 12 to the other user computing device 10, 12. Additionally, individual users participating in the collaborative environment may download and open a workspace file using a default application service (e.g., the whiteboarding application service) and then switch to the other application service without closing the workspace file 163.

[0051] In some instances, the web resources 155 available with a given workspace file 163 may include a design library of design elements that may be made available to one or both of the application services. In yet further instances, the design application library may be updated by a user using any of the application services. Moreover, in some variations, changes made by an individual user to design elements in the design library may be propagated to design libraries provided to other user computing devices (e.g., users of a collaborative session) and / or to instances of design interfaces rendered on the local canvases or collaborative media 102 of other users utilizing the particular design elements.

[0052] To illustrate the latter variation, users participating in a collaborative session may update the design elements used in conjunction with the active workspace file 163 of the collaborative session. In a further variation, the users may update the design elements using any of the application services. When a design element is in use on a collaborative medium 102 shared during a collaborative session, changes to the design element stored by the design library may be automatically detected by the network computer system 150, and the changes may be propagated to each design library downloaded to the user computing devices 10, 12, as well as to the design element rendered on the collaborative medium 102 (or canvas) of each individual user of the collaborative session.

[0053] The network computing system 150 can continuously synchronize the active workspace file 163 on each of the user computing devices 10, 12. In particular, changes made by a user to a selected active workspace file 163 on one computing device 10, 12 can be immediately reflected in the respective data structure representation 161 of the workspace file and rendered on the other user computing device 10, 12. Illustratively, a user of a computing device 10 can make changes to the respective workspace file 163 that is rendered on the collaborative medium 102, and the respective rendering engine 120 can implement updates that are reflected in the local copy of the data structure representation 111. From the computing device 10, the program interface 112 of the ICAP 100 can stream change data reflecting changes corresponding to the user input to the service component 160. The service component 160 processes the change data of the user computing device 10. The service component 160 can use the change data to make corresponding changes to the network side data structure representation 161. The service component 160 can also stream remotely generated change data (which in the provided example corresponds to or reflects the change data received from the user computing device 10) to the other user computing device 12 to cause the corresponding ICAP 100 to update the workspace file 163 rendered on the other device 10. The computing device 12 can also use the remotely generated change data to update with its local data structure representation 111. The program interface 112 of the computing device 12 can receive updates from the network computing system 150 and the rendering engine 120 can update the workspace file of the computing device 12 and its respective local copy of 111.

[0054] The reverse process may also be implemented to update the data structure representation 161 of the network computing system 150 with change data communicated from the second computing device 12 (e.g., corresponding to a user of the second computing device 12 updating the workspace file 163 rendered on the second computing device 12). The network computing system 150 may then stream the remotely generated change data (which in the provided example corresponds to or reflects the change data received from the user device 12) to update the local data structure representation 111 of the workspace file on the first computing device 10. In this manner, the workspace file 163 of the first computing device 10 may be updated in response to a user of the second computing device 12 providing user input to modify the workspace file 163.

[0055] To facilitate synchronization of the data structure representations 111 on the computing devices 10, 12, the network computing system 150 may implement stream connectors to merge data streams exchanged between the first computing device 10 and the network computing system 150, and between the second computing device 12 and the network computing system 150. In some implementations, the stream connectors may be implemented to allow each computing device 10, 12 to make changes to the network-side data representation 161 without additional data duplication that may possibly be required to process the streams from each device separately.

[0056] Additionally, over time, one or both of the computing devices 10, 12 may become out of sync with the server-side data representation 161. In such an event, each computing device 10, 12 may re-download the active workspace file 163 in order to resume maintaining the data structure representation 111 of the workspace file 163 as it is rendered and edited on that device.

[0057] Referring to FIG. 1, the widget runtime component 180 contains logic for synchronizing widget implementations among any number of computing devices sharing the multi-user canvas 102 in a collaborative session.

[0058] Any user of the user computing devices 10, 12 can activate a particular widget for a collaborative session. The initiating user's input can activate a widget for the shared collaborative medium 102. The widget runtime component 180 retrieves and executes the WPL 182 from the widget handler 166 to generate a widget object 185 on the collaborative medium 102 and determine a metadata set 184 representing the state of the widget object 185. The widget runtime component 180 can include synchronization logic 188 for generating widget synchronization data 187 and streaming it to the other collaborative computing device 10, 12. The widget synchronization data 187 can include data identifying updates to a widget rendering and data identifying updates to the metadata set 184 associated with the widget object 185. Thus, for example, the widget synchronization data 187 can include data reflecting a change in the visual state of a rendered widget or object, such as in the case of a preselection or feedback input (e.g., hover, etc.), and a position input associated with that input can cause the widget object to change its visual state. The widget synchronization data 187 may be received by the service component 160 and re-streamed to other computing devices 10 , 12 sharing the same collaborative medium 102 .

[0059] On each of the other respective computing devices 10, 12, the widget runtime component 180 executes the synchronization logic 188 to receive and act upon the widget synchronization data 187. In particular, the widget runtime component 180 may execute the synchronization logic 188 to generate and / or update the widget object 185 and associated metadata set 184. In this manner, the widget object 185 is rendered as part of the collaborative medium 102 on each collaborating user computing device 10, 12, and each computing device 10, 12 further associates a common metadata set 184 with the widget object 185. The widget object 185 may further remain a persistent feature of the collaborative medium 102 or the design 125 being edited. Moreover, as a persistent feature, the interactive widget object 185 may remain part of the collaborative medium 102 and may be available for use by computing devices 10, 12 operating in alternative modes and / or using different application services (e.g., whiteboard application vs. design interface) to render and update content presented on the collaborative medium 102. The widget object 185 may be further rendered to reflect changes in visual state resulting from input (e.g., pre-selected input, feedback, etc.) caused by pointer (or cursor) placement and movement of one or more other users of the collaborative session.

[0060] The widget runtime component 180 on each computing device 10, 12 may then be operable to detect the widget input and, in response, retrieve the associated WPL 182 based on the detected user input. Thus, the WPL 182 for the implemented widget is retrieved and executed in response to the user interaction. Further, in the illustrative example, only the computing device 10, 12 on which the widget input is received executes the WPL 182 to modify the widget object 185 and update the metadata set 184 to reflect the change in state of the widget object 185. The widget runtime component 180 utilizes synchronization logic 188 to stream the updated widget object 185 and metadata set 184 (or changes to the widget object 185 and / or metadata set 184) to the other computing device 10, 12. In this manner, the example provides for the WPL 182 to be executed on the computing device 10, 12 where the widget input is received, and a synchronization operation is used to update the widget object 185 and metadata set 184 on the other computing device 10, 12.

[0061] According to examples provided herein, execution of the synchronization logic 188 can render additional user action features on the collaborative medium 102, such that each collaborator in a collaborative session can see the labeled or unique cursor position of each other collaborator. For example, each cursor of each collaborator can be associated with a unique color and / or labeled with that collaborator's username. Position data 122 corresponding to the location of each collaborator's cursor position on the collaborative medium 102 can be streamed to the communication interface 105 of the network computing system 150 and dynamically tracked (e.g., by the service component 160) during the collaborative session. As provided herein, the cursor position can correspond to a mouse movement performed by a user on the collaborative medium 102, or a touch scroll input performed by a user on a touch-sensitive computing device.

[0062] Based on the streamed position data 122 from each user computing device 10, 12, the service component 160 can dynamically propagate visual state changes or other feedback resulting from cursor movement on the collaborative medium 102 such that each user computing device 10, 12 presents the real-time cursor movement of each collaborator. In the context of interactive widgets, a cursor position that overlaps with a bounding area of ​​a particular widget rendered on the collaborative medium 102 can cause the widget to provide a feedback response according to the widget's WPL 182. As described above, collaborators can make changes to widget size, widget interaction characteristics, and the manner in which the widget provides feedback responses to different user interactions, such as hover-over actions, focus actions (e.g., select and hold), and active actions (e.g., click actions).

[0063] According to the illustrated example, feedback responses to a widget object(s) 185 rendered on the collaborative medium 102 may be reflected on each of the user computing devices 10, 12. According to the WPL 182 of a particular widget, the feedback responses may comprise a fill response (e.g., the widget is highlighted or filled in with a particular color having a particular level of transparency or translucency when a particular user action occurs, such as a hover-over or mouse-over action on the widget), a stroke response (e.g., the outline or border of the widget is highlighted or changes color with a particular border width when a particular user action occurs, such as a selection or click action), a resize of the widget, the appearance of additional UI elements, etc. Additionally, the feedback responses may overlap or be layered when the widget object 185 includes nested responses, for example, a button located within another widget. In further examples described herein, multiple collaborators may interact with the same widget object 185 (e.g., hover over the same widget object with their respective cursors), which can cause a single feedback response to be propagated to all user computing devices 10, 12, or layered feedback responses to be propagated to all user computing devices 10, 12 (e.g., darkening of the fill or stroke response for any additional hover-overs).

[0064] During a collaborative session, cursor or input interface feature position data 122 for each user computing device 10, 12 may be tracked by the service component 160, which may continuously update the position of each cursor or input interface feature rendered on the collaborative medium 102 presented on each of the computing devices 10, 12. When a particular cursor or input interface feature interacts with a widget object 185, as determined from the position data 122, the service component 160 may send feedback response data 133 to the rendering engine 120 running on each of the user computing devices 10, 12 to cause a feedback response of the particular widget object 185 to be presented on the collaborative medium 102 displayed on each of the user computing devices 10, 12.

[0065] The service component 160 can further process input data 121 corresponding to a user input on a widget object(s) presented on the collaborative medium 102. Such input can comprise a focus or active input that selects the widget object 185 or can comprise an action that adjusts or updates the widget object 185. The WPL 182 for the widget object 185 can determine a feedback response for such input, and the service component 160 can responsively propagate the feedback response to each user computing device 10, 12 by sending feedback response data 133. Thus, the collaborative medium 102 presented on each user computing device 10, 12 can be continuously updated to provide feedback responses based on user actions performed on the widget object 185 by each and every collaborator.

[0066] In some instances, the WPL 182 for a displayed widget object 185 can include a feedback hierarchy for multi-user interactions on the widget. For example, an input feedback response (e.g., fill-in of a widget based on a collaborator selecting the widget) can be associated with a higher priority than a hover-over feedback response. In such instances, the service component 160 can identify multiple concurrent interactions with the widget and propagate the highest hierarchical feedback response to the computing device 10, 12. In further implementations, the WPL 182 can indicate non-conflicting feedback responses in which multiple feedback responses can be presented simultaneously, such as a first collaborator hovering or otherwise indicating a pre-selected input over the widget object 185 to trigger a stroke feedback response while a second collaborator selects the widget object 185 and triggers a fill feedback response. In such instances, the service component 160 can detect these concurrent interactions and propagate all non-conflicting feedback responses accordingly.

[0067] As provided herein, nested layered widget objects can provide multiple feedback responses over the collaborative medium 102 depending on the nature of the interactions and the number of concurrent interactions. When the service component 160 detects multiple interactions on a layered widget (e.g., a widget within a larger widget), the service component 160 can propagate each feedback response for the layered widget object 185 to the user computing device 10, 12 according to the WPL 182 of the nested widget object 185, as described in further detail below with respect to FIG.

[0068] methodology

[0069] FIG. 2 illustrates an exemplary method for tracking cursor positions and inputs and propagating feedback responses to collaborators' computing devices, according to one or more embodiments. In the following description of FIG. 2, reference may be made to reference numbers representing similar features as shown and described with respect to FIG. 1. Additionally, the process described with respect to FIG. 2 may be implemented by an exemplary networked computing system 150 as shown and described with respect to FIG. 1. Referring to FIG. 2, the computing system 100 may monitor (210) the cursor positions (or other input features) of each participating collaborator on the collaborative medium 102. The networked computing system 150 may continuously determine (215) whether any of the cursor positions hover or mouse over a widget object. When the computing system 150 detects (219) a cursor position within a bounded area of ​​a widget object, the computing system 150 propagates (220) a feedback response for the hover-over action to each user computing device 10, 12 in the collaborative session.

[0070] As provided herein, the feedback response for a hover-over or mouse-over action on a widget object may be a default response or may be determined from the WPL 182 of the widget object 185. Additionally, when multiple cursors are within a bounding area of ​​a widget object 185, the network computing system 150 may maintain the feedback response until the last widget object leaves the bounding area. In a variation, the network computing system 150 may cause the feedback response on the widget object 185 to change or increase in intensity or tone for each additional cursor that enters the bounding area of ​​the widget.

[0071] The network computing system 150 may further monitor (225) user input by collaborators performed on each presented widget object 185 of the collaborative medium 102. Such input may comprise pseudo-class user actions, such as active (e.g., select input (227), focus, focus-visible, or focus-in-action (229)). Based on each user input, the network computing system 150 may propagate (230) a specified feedback response for the input to all user computing devices 10, 12 in the collaborative session. Thus, the network computing system 150 provides real-time feedback to all collaborators providing user actions on widgets presented on the collaborative medium 102. Such feedback is intended to enhance the collaborative experience and make the collaborative session more interactive and efficient between collaborators.

[0072] It is further contemplated that feedback responses may be provided hierarchically when multiple user actions occur on a single widget object 185. For example, multiple cursors may be positioned at a bounding area of ​​a single widget object 185, which may cause the widget to provide a stroke response (e.g., the widget's outline may be highlighted). When one of the collaborators provides a selection input and a second collaborator maintains a hover-over state on the widget, the feedback hierarchy may provide that the stroke response is cancelled and a fill response is provided as long as the selection input is active. In a variation, two separate feedback responses may be active simultaneously (e.g., simultaneous stroke and fill responses on a single widget) based on the collaborators' user interactions on a single widget.

[0073] Widget feedback response example

[0074] 3A-3C illustrate example real-time feedback responses propagated to each user computing device 10, 12 for widgets available for the collaborative medium 102, according to one or more embodiments. In each feedback response example, a user action is performed with respect to a corresponding widget object (e.g., a hover-over action, a pre-selected input, a select action, a focus action, etc.) and may be propagated by the network computing system 150 to all user computing devices 10, 12 participating in the collaborative session. FIG. 3A illustrates an example of a deactivated widget 302 with no enabled feedback response (e.g., no action is performed on the corresponding widget object) and an activated widget 304 of the same when one or more of the collaborators provide a hover-over action on the corresponding widget object. The feedback response comprises a stroke response in which the border of the widget 304 is highlighted. The network computing system 150 can identify that the cursor position of one or more of the collaborators has entered the bounded area of ​​the widget 304 and, in response, propagates a corresponding feedback response about the widget to all other user computing devices 10, 12.

[0075] 3B illustrates a deactivation widget 306 and the same widget 308 providing a feedback response when one or more of the collaborators provide a hover-over action on the widget 308. The feedback response comprises a fill response, where the entire widget is filled in with a particular color having a transparency level. Again, the network computing system 150 identifies that the cursor position of one or more of the collaborators has entered the bounded area of ​​the widget 308 and accordingly propagates a corresponding feedback response for the widget to all other user computing devices 10, 12.

[0076] FIG. 3C illustrates a layered widget 312 within an underlying widget 310 that provides nested feedback to collaborators. Multiple feedback responses may be propagated for such layered widgets 310, 312 when single or multiple user actions are detected. For example, a hover-over action on the widget 310 but not within the bounding area of ​​the widget 312 may cause both a fill response to occur over the entire bounding area of ​​the widget 310 (as shown) and a stroke response to occur on the inner widget 312. In this example, when a cursor position is also detected within the bounding area of ​​the widget 312, an additional feedback response may be propagated for the widget 312 (e.g., an additional fill response). Furthermore, when an additional user action, such as a selection input or focus input, occurs on a nested widget while the widget 310 is being filled, the network computing system 150 may propagate the specified feedback response for the additional user action to all user computing devices 10, 12 in real time. Thus, multiple feedback responses may be propagated for a single widget based on multiple user actions performed on that widget, and for a layered widget when multiple user actions occur on any one or more of the bounding areas of the layered widget.

[0077] Network Computer Systems

[0078] 4 illustrates a computer system upon which one or more embodiments may be implemented. Computer system 400 may be implemented, for example, on a server or combination of servers. For example, computer system 400 may be implemented as network computing system 150 of FIG. 1.

[0079] In one implementation, computer system 400 includes processing resources 410, memory resources 420 (e.g., read-only memory (ROM) or random-access memory (RAM)), one or more instruction memory resources 440, and a communication interface 450. Computer system 400 includes at least one processor 410 for processing information stored by memory resources 420, such as provided by a random access memory (RAM) or other dynamic storage device for storing information and instructions executable by processor 410. Memory resources 420 may also be used to store temporary variables or other intermediate information during execution of instructions to be executed by processor 410.

[0080] The communications interface 450 enables the computer system 400 to communicate with one or more user computing devices over one or more networks (e.g., cellular networks) through the use of a network link 480 (wireless or wired). Using the network link 480, the computer system 400 can communicate with one or more computing devices, specialized devices and modules, and / or one or more servers.

[0081] In an example, the processor 410 may execute service instructions 422 stored by the memory resources 420 to enable the network computing system to implement the network service 152 and operate as the network computing system 150, such as in an example described in conjunction with FIG. 1.

[0082] Computer system 400 may also include additional memory resources ("instruction memory 440") for storing executable instruction sets ("ICAP instructions 445") embedded with web pages and other web resources to enable user computing devices to implement functionality as described in conjunction with ICAP 100. In an illustrative example, computer system 400 may communicate ICAP instructions 445 to collaborator's computing devices during a collaborative session.

[0083] Thus, the examples described herein relate to the use of computer system 400 to implement the techniques described herein. According to one aspect, the techniques are performed by computer system 400 in response to processor 410 executing one or more sequences of one or more instructions contained in memory 420. Such instructions may be read into memory 420 from another machine-readable medium. Execution of the sequences of instructions contained in memory 420 causes processor 410 to perform the process steps described herein. In alternative implementations, hardwired circuitry may be used in place of or in combination with software instructions to implement the examples described herein. Thus, the examples described are not limited to any specific combination of hardware circuitry and software.

[0084] User Computing Device

[0085] 5 illustrates a user computing device for use with one or more embodiments as described. In an embodiment, the user computing device 500 may correspond to, for example, a workstation, desktop computer, laptop, or other computer system having graphics processing capabilities suitable for enabling rendering of a design interface and graphic design work. In a variant, the user computing device 500 may correspond to a mobile computing device, such as a smartphone, tablet computer, laptop computer, VR or AR headset device, etc.

[0086] In the illustrative example, computing device 500 includes a central or main processor 510, a graphics processing unit 512, memory resources 520, and one or more communication ports 530. Computing device 500 may use main processor 510 and memory resources 520 to store and launch a browser 525 or other web-based application. A user may operate browser 525 using communication port 530 to access a network site of network service 152, and one or more web pages or other resources 505 for network service 152 (see FIG. 1) may be downloaded. Web resources 505 may be stored in active memory 524 (cache).

[0087] As will be described with various examples, the processor 510 can detect and execute scripts and other logic embedded in the web resources to implement the ICAP 100 (see FIG. 1). In some of the examples, some of the scripts 515 embedded in the web resources 505 can include GPU-accelerated logic executed directly by the GPU 512. The main processor 510 and the GPU can combine to render the collaborative media 102 (e.g., corresponding to the workspace file 163) on the display component 540. The rendered collaborative media 102 can include web content from the browser 525, as well as design interface content and functional elements generated by the scripts and other logic embedded in the web resources 505. By including scripts 515 that are directly executable on the GPU 512, the logic embedded in the web resources 505 can better execute the ICAP 100, as will be described with various examples.

[0088] conclusion

[0089] Although examples are described in detail herein with reference to the accompanying drawings, it should be understood that the concept is not limited to those exact examples. The scope of the concept is therefore to be defined by the following claims and their equivalents. Furthermore, it is contemplated that a particular feature described either individually or as part of an example may be combined with other individually described features or parts of other examples, even if those other features and examples do not mention that particular feature. Thus, the absence of a description of a combination should not exclude the right to such a combination.

Claims

1. a network communications interface for communicating over one or more networks with a plurality of user computing devices of collaborators participating in a collaborative session, each of the plurality of user computing devices displaying a collaborative user interface comprising one or more widgets; one or more processors; A memory for storing instructions; wherein the instructions, when executed by the one or more processors, cause the network computing system to: receiving, over the one or more networks, from each of the plurality of user computing devices, position data indicative of a cursor position on the collaborative user interface for each collaborator in the collaborative session; determining whether the cursor position of each of the collaborators is within a bounding area of ​​a widget of the one or more widgets based on the position data; sending feedback response data to each of the plurality of user computing devices to cause a corresponding feedback response about the widget to be presented on the collaborative user interface displayed on each of the plurality of user computing devices when the cursor position of the respective collaborator is within the bounding area of ​​the widget; A network computing system that performs the above.

2. The executed instructions further include causing the network computing system to: receiving, over the one or more networks, input data from each of the plurality of user computing devices indicative of user inputs performed on the widget by the collaborators; determining a respective feedback response for the user input performed on the widget based on the input data; transmitting, over the one or more networks, second feedback response data to the plurality of user computing devices, causing each of the plurality of user computing devices to present a corresponding feedback response for each of the user inputs on the widget; 2. The network computing system of claim 1, further comprising:

3. 3. The networking computing system of claim 2, wherein the corresponding feedback response based on the user input on the widget is determined by performing a lookup in widget programming logic of the widget.

4. The network computing system of claim 2 , wherein the corresponding feedback response based on the user input comprises at least one of a fill response or a stroke response.

5. 2. The network computing system of claim 1, wherein the cursor position of the respective collaborator being within the bounded area of ​​the widget comprises a hover-over action on the widget.

6. The network computing system of claim 1 , wherein the corresponding feedback response for the widget comprises a fill response or a stroke response.

7. 2. The network computing system of claim 1, wherein the corresponding feedback response is determined by widget programming logic of the widget.

8. The widget is located within a second widget, and the executed instructions further include informing the network computing system of: transmitting, over the one or more networks, second feedback response data to the plurality of user computing devices that causes each of the plurality of user computing devices to present a second feedback response for the second widget on the collaborative user interface displayed on each of the plurality of user computing devices.

2. The network computing system of claim 1, further comprising:

9. A non-transitory computer-readable medium storing instructions that, when executed by one or more processors of a computing system, cause the computing system to: receiving, over one or more networks, from each of a plurality of user computing devices operating in a collaborative session, position data indicative of a cursor or pointer position on a collaborative user interface or medium for each collaborator in the collaborative session; determining whether the cursor position of each of the collaborators is within a bounding area of ​​a widget of the one or more widgets based on the position data; sending feedback response data to each of the plurality of user computing devices to cause a corresponding feedback response about the widget to be presented on the collaborative user interface displayed on each of the plurality of user computing devices when the cursor position of the respective collaborator is within the bounding area of ​​the widget; A non-transitory computer-readable medium for performing operations including:

10. The operation includes: receiving, over the one or more networks, input data from each of the plurality of user computing devices indicative of user inputs performed on the widget by the collaborators; determining a respective feedback response for the user input performed on the widget based on the input data; transmitting, over the one or more networks, second feedback response data to the plurality of user computing devices, causing each of the plurality of user computing devices to present a corresponding feedback response for each of the user inputs on the widget; 10. The non-transitory computer-readable medium of claim 9, further comprising:

11. 11. The non-transitory computer-readable medium of claim 10, wherein the corresponding feedback response based on the user input on the widget is determined by performing a lookup in widget programming logic of the widget.

12. The non-transitory computer-readable medium of claim 10 , wherein the corresponding feedback response based on the user input comprises at least one of a fill response or a stroke response.

13. 10. The non-transitory computer-readable medium of claim 9, wherein the cursor position of the respective collaborator being within the bounded area of ​​the widget comprises a hover-over action on the widget.

14. The non-transitory computer-readable medium of claim 9 , wherein the corresponding feedback response for the widget comprises a fill response or a stroke response.

15. 10. The non-transitory computer-readable medium of claim 9, wherein the corresponding feedback response is determined by widget programming logic of the widget.

16. 11. The non-transitory computer-readable medium of claim 10, wherein the corresponding feedback response based on the user input on the widget is determined by performing a lookup in widget programming logic of the widget.

17. receiving, over one or more networks, from each of a plurality of user computing devices operating in a collaborative session, position data indicative of a cursor or pointer position on a collaborative user interface or medium for each collaborator in the collaborative session; determining whether the cursor position of each of the collaborators is within a bounding area of ​​a widget of the one or more widgets based on the position data; sending feedback response data to each of the plurality of user computing devices to cause a corresponding feedback response about the widget to be presented on the collaborative user interface displayed on each of the plurality of user computing devices when the cursor position of the respective collaborator is within the bounding area of ​​the widget; 4. A computer-implemented method comprising:

18. The method of claim 17 , wherein the cursor position of the respective collaborator being within the bounded area of ​​the widget comprises a hover-over action on the widget.

19. The method of claim 17 , wherein the corresponding feedback response for the widget comprises a fill response or a stroke response.

20. The method of claim 17 , wherein the corresponding feedback response is determined by widget programming logic of the widget.

Images