An interactive system for automatic execution of plugins

Abstract

The interaction system is extensibly configured to enable the use of plugins that detect content entry inputs of each of one or more users on the user-generated content of the canvas. In response to detecting each content entry input, the interaction system (i) automatically triggers execution of a plugin, the plugin implemented as a program that runs separately from the interaction system, and (ii) renders at least a first output generated by the execution of the plugin with the user-created content.

Description

Description of Related Applications

[0001] This patent application claims the benefit of priority to U.S. Provisional Patent Application No. 63 / 430,663, filed December 6, 2022. The above-mentioned priority application is incorporated herein by reference for all purposes. [Technical Field]

[0002] The examples described herein relate to an interactive system for the automatic execution of plug-ins. [Background technology]

[0003] Software design tools come in many forms and uses. For example, in the area of ​​application user interfaces, software design tools require designers to blend the functionality of a program with aesthetic and even legal requirements, resulting in a collection of pages that form the application's user interface. Summary of the Invention [Problem to be solved by the invention]

[0004] For a given application, the designer often has many objectives and requirements that are difficult to keep track of. [Means for solving the problem]

[0005] An embodiment provides an interactive system or platform that includes a plug-in management system to enable a user to search for and execute a desired plug-in. In an example, the plug-in management system provides a search user interface to receive input from a user as well as parametric values ​​to be used by the selected plug-in. The plug-in management system executes the identified plug-in using the user-specified parametric values ​​based on the user's interaction with the search user interface.

[0006] In an example, a system may integrate a plugin system to implement multiple types of plugins (e.g., multiple types of spell checkers) in the context of a graphic design system, where the functionality or output of the additional plugins utilizes the output or functionality of concurrently executing program components (e.g., system components, default plugins, etc.).

[0007] In an example, a computer system is configured to implement an interactive system or platform for enabling users to create various types of content, such as graphic designs, whiteboards, presentations, web pages, and other types of content. Among other advantages, in the example as described, such users may utilize plug-ins to extend or supplement the functionality of the interactive system to suit their particular needs.

[0008] Further, in some examples, a networked computer system is provided that includes memory resources that store an instruction set, and one or more processors that are operable to communicate the instruction set to a plurality of user devices. The instruction set can be communicated to the user computer devices in connection with the user computer devices operating to render content on a canvas, and the design can be edited by user input indicating any one of a plurality of different input actions. The instruction set can be executed on the computer devices to cause each of the computer devices to determine one or more input actions to perform based on the user input. The instructions can further cause the user computer devices to perform the one or more input actions to modify the content. In such examples, the interactive system includes a plugin management system that allows a user to search for and execute plugins that extend or supplement the functionality provided by the plugin management system.

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

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

[0011] Some embodiments described herein may generally require the use of computing devices that include processing and memory resources. For example, one or more embodiments described herein may be implemented, in whole or in part, on computing devices such as servers, desktop computers, mobile phones or smartphones, tablets, wearable electronic devices, laptop computers, printers, digital picture frames, network equipment (e.g., routers), and tablet devices. Memory, processing, and network resources may all be used in connection with establishing, using, or executing any embodiment described herein (including performing any method or implementing any system).

[0012] Furthermore, one or more embodiments described herein may be implemented using instructions executable by one or more processors. These instructions may be carried on a computer-readable medium. The machines shown in or described in the following figures provide examples of processing resources and computer-readable media on which instructions for implementing embodiments of the present invention may be carried and / or executed. In particular, many machines illustrated with embodiments of the present invention include a processor and various forms of memory for retaining data and instructions. Examples of computer-readable media include permanent memory storage devices such as hard drives in personal computers or servers. Other examples of computer storage media include portable storage devices such as CDs and DVD units, flash memory (such as those found in smartphones, multifunction devices, or tablets), and magnetic memory. Computers, terminals, and network-enabled devices (e.g., mobile devices such as mobile phones) are all examples of machines and devices that utilize processors, memory, and instructions stored on a computer-readable medium. Additionally, embodiments may be implemented in the form of a computer program or a computer-usable carrier medium capable of carrying such a program. [Brief explanation of the drawings]

[0013] [Figure 1A] FIG. 1 illustrates an interactive system for a user's computing device, according to one or more examples. [Figure 1B] FIG. 1 illustrates a networked computer system for implementing an interactive system on a user computer device, according to one or more examples. [Figure 1C] FIG. 1 illustrates a networked computer system for implementing an interactive system for multiple users in a collaborative network platform, according to one or more examples. [Figure 2] FIG. 1B illustrates a plug-in management system for use in the example described with respect to FIGS. 1A-1C. [Figure 3A]1 is a flow diagram of an example method for executing a plug-in associated with a content entry on a canvas, according to one or more embodiments. [Figure 3B] 1 is a flow diagram of an example method for executing a plug-in associated with a content entry on a canvas, according to one or more embodiments. [Figure 4A] FIG. 1 illustrates an example interface that can be generated for a canvas, according to one or more embodiments. [Figure 4B] FIG. 1 illustrates an example interface that can be generated for a canvas, according to one or more embodiments. [Figure 4C] A diagram illustrating a sequence in which a content element or entry is automatically detected and a selected plug-in identifies or generates a corresponding image, according to one or more examples. [Figure 4D] A diagram illustrating a sequence in which a content element or entry is automatically detected and a selected plug-in identifies or generates a corresponding image, according to one or more examples. [Figure 5] FIG. 1 illustrates a computer system in which one or more embodiments may be implemented. [Figure 6] FIG. 1 illustrates a user computing device for use with one or more of the described examples. DETAILED DESCRIPTION OF THE INVENTION

[0014] System Description 1A illustrates an interactive system for a user's computing device, according to one or more examples. The interactive system 100 can be implemented in any one of several different computing environments. For example, in some variations, the system 100 can be implemented as a client-side application running on the user computing device 10 to provide functionality as described in the various examples. In other examples, as described below, the system 100 can be implemented through the use of a web-based application 80. Additionally or alternatively, the system 100 can be implemented as a distributed computing environment, in which the processes described in the various examples run on network computers (e.g., servers) and / or on the user device 10.

[0015] According to an example, an interactive system 100 is implemented on a user computing device 10 to enable a corresponding user to generate content such as interactive designs or whiteboards. The system 100 may include processes executed as or through a web-based application 80 installed on the computing device 10. As illustrated by various examples, the web-based application 80 may execute scripts, code, and / or other logic (“program components”) to implement the functionality of the interactive system 100. Furthermore, in some variations, the system 100 may be implemented as part of a network service, and the web-based application 80 may communicate with one or more remote computers (e.g., servers used for the network service) to execute the processes of the system 100.

[0016] In some examples, the web-based application 80 obtains some or all of the program resources for implementing the system 100 from a network site. Additionally or alternatively, the web-based application 80 can obtain some or all of the program resources from a local source (e.g., local memory resident on the computing device 10). The web-based application 80 can also access various types of datasets in providing functions or services for the interactive system 100. The datasets can correspond to files and libraries, which can be stored remotely (e.g., on a server, associated with an account), locally, or distributed between local and network resources.

[0017] In an example, the web-based application 80 may be compatible with commercially available browsers such as GOOGLE CHROME (developed by GOOGLE, INC.), SAFARI (developed by APPLE, INC.), and INTERNET EXPLORER (developed by MICROSOFT CORPORATION). In such an example, the processes of the interactive system 100 may be implemented as scripts and / or other embedded code that the web-based application 80 downloads from a network site. For example, the web-based application 80 may execute code embedded within a web page to implement the processes of the system 100. The web-based application 80 may also execute scripts to obtain other scripts and program resources (e.g., libraries) from the network site and / or other local or remote locations. As an example, the 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 examples, the rendering engine 120 and / or other components may utilize GPU acceleration logic, such as that provided through Web Graphics Library (WebGL) programs that execute Graphics Library Shader Language (GLSL) programs running on a graphics processing unit (GPU).

[0018] According to an example, a user of computing device 10 operates web-based application 80 to access network sites to obtain and execute program resources to implement interactive system 100. In one example, a user may initiate a session to implement interactive system 100 for purposes of creating and / or editing graphic design, whiteboards, presentations, web pages, or other types of content. In the example, system 100 includes program interface 102, input interface 118, and rendering engine 120. Program interface 102 may include one or more processes executed to access and obtain program resources from local and / or remote sources.

[0019] In some implementations, the programmatic interface 102 can use programmatic resources associated with the web-based application 80 (e.g., an HTML 5.0 canvas), for example, to generate the canvas 122. Additionally or alternatively, the programmatic interface 102 can trigger or otherwise generate the canvas 122 using programmatic resources and data sets (e.g., canvas parameters) obtained from a local source (e.g., memory) or a remote source (e.g., a network service).

[0020] The program interface 102 may also obtain program resources including an application framework for use with the canvas 122. The application framework may include, for example, a data set that defines or configures a set of interactive tools that are integrated with the canvas 122 and that configure the input interface 118, allowing a user to provide input to create and / or edit predetermined content (e.g., a graphic design, a whiteboard, a presentation, a web page, etc.).

[0021] According to some examples, the input interface 118 can be integrated with the canvas 122 and implemented as a functional layer that detects and interprets user input. The input interface 118 can, for example, identify the on-screen location of a user input (e.g., a “click”) using a reference to the canvas 122. Furthermore, the input interface 118 can interpret a user's input action based on the location of the detected input (e.g., whether the location of the input indicates a tool selection, an object rendered on the canvas, or an area of ​​the canvas), the frequency of the detected input over a given period of time (e.g., a double-click), and / or the start and end positions of an input or series of inputs (e.g., the start and end positions of a click and drag), as well as various other input types (e.g., a right-click, a screen tap, etc.) that a user can specify through one or more input devices. In this manner, the input interface 118 can, for example, interpret a series of inputs as a design tool selection (e.g., a shape selection based on the input location) or as input for defining attributes (e.g., dimensions) of the selected shape.

[0022] Additionally, the program interface 102 can be used to retrieve program resources and data sets, including files 101 that constitute the user's active workspace, from local or remote sources. The retrieved data sets can include, for example, one or more pages containing content elements that collectively form predetermined content. As an example, the content can correspond to a design interface, a whiteboard, a web page, or other content medium. Each file 101 can include one or more data structure representations 111 that collectively define the design interface. The files 101 can also include additional data sets associated with the active workspace. For example, as described in some examples, individual pages of the active workspace can be associated with a set of constraints 145. As a further example, the program interface 102 can retrieve (e.g., from a network service 152 (see FIG. 1B), local memory, etc.) one or more types of profile information 109, such as user profile information that can identify the user's past activities of the computing device 10 when utilizing the interactive system 100. The profile information 109 can, for example, identify the user's input type (or action) with respect to a page of the active workspace, or, more generally, the user's input actions in a previous time interval. In some variations, the profile information 109 may also identify historical or contextual information about individual design interfaces, as represented by corresponding data structure representations 111 .

[0023] In an example, the rendering engine 120 uses the data structure representation 111 to render corresponding content 125 on the canvas 122, where the content 125 reflects the elements or components and their respective attributes that may be provided with individual pages of the file 101. A user can edit the content 125 using the input interface 118. Alternatively, the rendering engine 120 can generate a blank page of the canvas 122, and a user can generate the content 125 using the input interface 118. As an example, the content 125 can include graphic elements, such as a background and / or a set of objects (e.g., shapes, text, images, program elements), as well as attributes of the individual graphic elements. Each attribute of a graphic element can include an attribute type and an attribute value. For objects, the attribute type can include shape, dimension (or size), layer, type, color, line thickness, text size, text color, font, and / or other visual characteristics. Depending on the implementation, the attributes reflect properties of a two-dimensional or three-dimensional design. In this manner, the attribute values ​​of individual objects can define, for example, the size, color, position, layering, and visual characteristics of the content that is rendered as part of content 125 .

[0024] In examples, individual design elements may also be defined according to desired runtime behavior. By way of example, some objects may be defined to have either static or dynamic runtime behavior. The attributes of dynamic objects may change in response to predefined runtime events generated by the underlying application that is to incorporate the content 125. Additionally, some objects may be associated with logic that defines the object as a trigger for rendering or modifying other objects, such as through the implementation of a sequence or workflow. Still other objects may be associated with logic that provides conditionality for when the design element is rendered and / or its respective configuration or appearance when rendered. Furthermore, objects may be defined as interactive, such that one or more attributes of the object change based on user input during the runtime of the application.

[0025] As described through the examples, the interactive system 100 enables a user to use plug-ins. A plug-in can be selected and executed to perform a specific set of operations, and execution of the plug-in can modify the content 125 on the canvas 122. For example, a plug-in library can be stored on the user computing device 10 and / or on a network site where the interactive system 100 is located. Furthermore, in the examples, plug-ins can be used to perform difficult or time-consuming tasks. For example, in an implementation in which the system 100 enables the creation of interactive graphic designs, plug-ins can be executed to create specific types of content graphic content elements (e.g., generating iconic representations of people, creating interactive tables, etc.). Furthermore, plug-ins can be configured to perform tasks that modify attributes of content elements. For example, a plug-in can be executed to automatically replace the occurrence of an attribute (e.g., fill color, line color, etc.) with another attribute. Furthermore, plug-ins can implement other types of tasks, such as exporting a content element or creating a dataset (e.g., program code) for a specified content element. These examples illustrate various ways in which plug-ins can be incorporated and used in the interactive system 100 as described through the various examples.

[0026] Network Computer System 1B illustrates a networked computer system for implementing an interactive system on a user computer device, according to one or more examples. A networked computer system such as that illustrated in the example of FIG. 1B can be implemented, for example, using one or more servers that communicate with the user computer device over one or more networks.

[0027] 1B example, networked computer system 150 performs operations to enable interactive system 100 to be implemented on user computing device 10. In a variation, networked computer system 150 provides network services 152 to support use of interactive system 100 by user computing devices utilizing browsers or other web-based applications. Networked computer system 150 may include a site manager 158 that manages a website where a set of web resources 155 (e.g., web pages) are made available for site visitors. Web resources 155 may include instructions ("system instructions 157") such as scripts or other logic executable by a browser or web component of a user computing device.

[0028] In some variations, when computing device 10 accesses and downloads web resource 155, web-based application 80 executes system instructions 157 to implement functionality such as those described in some examples of FIG. 1A. For example, system instructions 157 may be executed by web-based application 80 to launch program interface 102 on user computing device 10. The launch of program interface 102 may occur simultaneously with, for example, the establishment of a WebSocket connection between program interface 102 and service component 160 of networked computing system 150.

[0029] In some examples, the web resources 155 include logic that the web-based application 80 executes to launch one or more processes of the program interface 102, thereby causing the interactive system 100 to obtain additional program resources and data sets for implementing functionality as described by the examples. The web resources 155 may, for example, embed logic (e.g., JAVASCRIPT code), including GPU acceleration logic, in an HTML page for download by a user's computing device. The program interface 102 may be triggered to obtain additional program resources and data sets, for example, from the network service 152 and / or from local resources of the computing device 10, to implement the interactive system 100. For example, some of the components of the interactive system 100 may be implemented through web pages that can be downloaded to the computing device 10 after authentication has been performed and / or once the user has performed additional actions (e.g., downloading one or more pages of a workspace associated with an account identifier). Thus, in the illustrated example, the network computer system 150 can communicate system instructions 157 to the computing device 10 through a combination of network communications, including through an activity download of the web-based application 80, where the system instructions 157 are received and executed by the web-based application 80.

[0030] Computing device 10 may use web-based application 80 to access a website of network service 152 and download web pages or web resources. Upon accessing the website, web-based application 80 may communicate an account identifier to service component 160 automatically (e.g., through stored credentials) or through manual entry. In some examples, web-based application 80 may also communicate one or more additional identifiers that correlate with the user identifier.

[0031] Further, in some examples, the service component 160 can use the user or account identifier of the user identifier to retrieve the profile information 109 from the user profile store 166. Additionally or alternatively, the user's profile information 109 can be determined and stored locally on the user's computing device 10.

[0032] The service component 160 can also retrieve from the file store 164 a file of an active workspace linked to a user account or identifier ("active workspace file 163"). The profile store 166 can also identify a workspace identified with the account and / or user, and the file store 164 can store the datasets that make up the workspace. The datasets stored in the file store 164 can include, for example, the pages of the workspace, a dataset identifying constraints for the active set of workspace files, and one or more data structure representations 161 of the design being edited that can be rendered from each active workspace file.

[0033] Further, in examples, the service component 160 provides the web-based application 80 with a representation 159 of a workspace associated with the user, which representation identifies, for example, individual files associated with the user and / or user account. The workspace representation 159 can also identify a set of files, each file including one or more pages, and each page including objects that are part of a design interface.

[0034] On the user device 10, a user can view the workspace representation through a web-based application 80, and the user can select to open a file of the workspace through the web-based application 80. In an example, when a user selects to open one of the active workspace files 163, the web-based application 80 launches a canvas 122. For example, the interactive system 100 can launch an HTML 5.0 canvas as a component of the web-based application 80, and a rendering engine 120 can access one or more data structure representations 111 to render or update corresponding content 125 on the canvas 122.

[0035] 1B , the networked computer system 150 enables the user computer device 10 to implement the plug-in subsystem 200. For example, the networked computer system 150 may provide the computer device 10 with logic to cause the computer device 10 to implement the plug-in subsystem 200. Additionally, in some examples, the networked computer system 150 may store a library or collection of plug-ins that are made available to individual users through a search user interface as described in other examples. In this manner, users of the computer device 10 can search for and execute desired plug-ins to extend or supplement the functionality of the interactive system 100.

[0036] Collaborative Network Platform 1C illustrates a networked computer system for implementing an interactive system for multiple users in a collaborative network platform, according to one or more examples. In the example of FIG. 1C, the collaborative network platform is implemented by a networked computer system 150, which communicates with multiple user computer devices 10, 12 over one or more networks (e.g., the World Wide Web) to implement the interactive system 100 on the user computer devices 10, 12. While FIG. 1C illustrates an example in which two users utilize the collaborative network platform, in the illustrated example, the networked computer system 150 enables collaboration on design interfaces among a larger group of users.

[0037] 1C, the user computing devices 10, 12 can be assumed to be operated by multiple users associated with a common account, with each user computing device 10, 12 implementing an instance of the interactive system 100 to access the same workspace during their respective overlapping sessions. Thus, each of the user computing devices 10, 12 can simultaneously access the same set of active workspace files 163, and the respective programmatic interfaces 102 of the interactive system 100 on each user computing device 10, 12 operate to establish a corresponding communication channel (e.g., a WebSocket connection) with the service component 160.

[0038] In an example, 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 content 125 of the active workspace file 163. Additionally, each of the computing devices 10, 12 can maintain a local data structure representation 111 of the respective content 125 as determined from the active workspace file 163. The service component 160 can also maintain a network-side data structure representation 161 that is obtained from the file of the active workspace 163 and that matches the local data structure representation 111 of each of the computing devices 10, 12.

[0039] The networked computing system 150 can continuously synchronize the active workspace files 163 on each user computing device. In particular, changes made by each user to the content 125 on their respective computing devices 10, 12 can be immediately reflected in the rendered content 125 on the other user computing device 10, 12. As an example, a user of a computing device 10 can make changes to their respective content 125, and their respective rendering engines 120 can implement updates that are reflected in their local copies of the data structure representation 111. From the computing device 10, the programmatic interface 102 of the interactive system 100 can stream change data 121 reflecting the user input changes to the service component 160. The service component 160 processes the change data 121 on the user computing device. The service component 160 can use the change data 121 to make corresponding changes to the network-side data structure representation 161. The service component 160 can also stream remotely generated change data 171 (which, in the provided example, corresponds to or reflects change data 121 received from the user device 10) to the computing device 12 to cause the corresponding instance of the interaction system 100 to update the content 125 rendered on that device. The computing device 12 can also use the remotely generated change data 171 to update its local data structure representation 111. The program interface 102 of the computing device 12 can receive the updates from the networked computer system 150, and the rendering engine 120 can update its respective local copies of the content 125 and 111 on the computing device 12.

[0040] The reverse process may also be implemented to update the data structure representation 161 of the networked computer system 150 using change data 121 communicated from the second computing device 12 (e.g., corresponding to a user of the second computing device updating the content 125 rendered on the second computing device 12). The networked computer system 150 may then stream remotely generated change data 171 (which, in the provided example, corresponds to or reflects the change data 121 received from the user device 12) to update the local data structure representation 111 of the content 125 on the first computing device 10. In this manner, the content 125 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 content 125.

[0041] To facilitate synchronization of the data structure representations 111, 111 on the computing devices 10, 12, the network computing system 150 may implement stream connectors that merge data streams exchanged between a first computing device 10 and the network computing system 150, and between a 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 the additional data duplication that may be required to process the streams from each device individually.

[0042] 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 to resume maintenance of the data structure representation of the content 125 that is rendered and edited on that device.

[0043] 1C , the networked computer system 150 enables each computing device 10, 12 to implement a plug-in subsystem 200. For example, the networked computer system 150 can communicate instructions that cause each computing device 10, 12 to implement the plug-in subsystem 200 as part of the interactive system 100. Additionally, in some examples, the networked computer system 150 can store a library or collection of plug-ins that are made available to users of the computing devices 10, 12 through a search user interface as described in other examples. In this manner, users can search for and execute desired plug-ins to extend or supplement the functionality of the interactive system 100.

[0044] Plugin Management System Figure 2 illustrates a plug-in management system for use in examples such as those described in Figures 1A-1C. In some examples, the plug-in subsystem 200 is provided as part of the interactive system 100. In an alternative embodiment, the plug-in subsystem 200 may be provided by, for example, the network computer system 150 in association with users utilizing the interactive system 100 on their respective computing devices 10, 12.

[0045] According to an example, the interactive system is configured to be extensible for the purpose of enabling the execution of plug-ins from a plug-in library. Each plug-in may be implemented as a program that runs separately from the interactive system. The plug-ins may be executed to augment or extend the functionality of the interactive system. An end user may, for example, use the interactive system 100 and execute the plug-ins in connection with creating or updating designs or other content provided on the canvas 122.

[0046] As shown, plug-in subsystem 200 includes processes that, when implemented, provide the functionality represented by canvas interface 210 and content processing interface 220. Additionally, plug-in subsystem 200 includes plug-in library 250 for providing a library or collection of plug-ins.

[0047] The plug-in library 250 includes program files (e.g., executable files) that can be executed at the option of an end user in connection with the end user's use of the interactive system 100 to create and / or update content rendered on a canvas. Plug-ins can be created by developers, including third parties to the owner of the interactive system 100. In examples, each plug-in can be executed at the option of a user to implement a process separate from the functionality of the interactive system 100. Thus, plug-ins stored in the plug-in library 250 can provide additional or enhanced functionality for use with the interactive system 100.

[0048] In an example, a developer can interact with the plug-in subsystem 200 to store plug-in files 255 (or sets of files used at runtime) in the plug-in library 250. The plug-in files 255 can include one or more executable files for executing the corresponding plug-in. Developers can utilize the developer interface 260 to add plug-in files to the plug-in library 250 or to update existing plug-ins. While one example provides plug-ins that are created by developers, in variations, plug-ins can also be designed and implemented by the creator of the interactive system 100. For example, the creator of the interactive system 100 can design a plug-in that enhances the functionality of the interactive system 100, and that functionality will be utilized by a relatively limited number of users.

[0049] Plug-in detection and execution According to an example, the canvas interface 210 provides functionality for detecting and processing content entry input 211, such as may be generated by the rendering engine 120 and / or through other processes of the interaction system 100. The content entry input 211 may be a particular type of input (e.g., alphanumeric input, such as entered by typing) that results in content elements being rendered or modified on the canvas 122. For example, the interaction system 100 may render designs that include graphical content as well as text input, and a user may operate the interaction system 100 in a text input mode to input text that forms part of the graphic design (as compared to a graphical mode in which the user inputs visual elements such as shape elements or frames). Thus, the canvas interface 210 may include program processes that capture content entry input 211 (e.g., keystroke input, such as generating alphanumeric input), which results in content being generated or modified on the canvas 122 (e.g., character input).

[0050] The canvas interface 210 may also provide one or more interactivity features 212 with the canvas 122. The interactivity features 212 may be provided by interactive windows or menus and / or design tools (e.g., panel feature(s)). As described in more detail, the interactivity features 212 may include elements (e.g., options) configurable to display or otherwise indicate output generated by the canvas interface 210 and / or plug-ins 224. Additionally, the interactivity features 212 include elements configurable by output generated by program processes of the canvas interface.

[0051] The content processing interface 220 triggers the execution of one or more program processes, including native program processes (or “native plug-ins”) and plug-ins 224 of the plug-in library 250, based on or in response to the content entry input 211. The content processing interface 220 can execute the plug-ins 224 to generate one or more plug-in outputs 223, each of which (i) supplements or enhances the content rendered on the canvas 122 and / or (ii) provides or modifies interactive functionality or elements thereof for use in editing or manipulating the content rendered on the canvas 122. As illustrated in Figures 4A through 4C, the plugin output 223 may include (i) identification of words, terms, or characters that appear on the canvas 122 and that have been processed by the respective plugin 224; (ii) temporary visual elements that overlay or appear alongside canvas content elements, such as basic or other text effects that the canvas interface 210 may implement using the processed content (e.g., words, characters, sentences, etc.); (iii) menus or menu items that include the plugin output and allow the user to modify existing content on the canvas 122 by interacting with the menu items; and / or (iv) content that modifies the content of the canvas 122, such as text content that is inserted into the canvas 122 (e.g., replacing other text content).

[0052] Additionally, in some variations, a predetermined plug-in can be executed to generate functional elements with which a user can interact alongside the process content items (e.g., words on the canvas 122). For example, the content processing interface 220 can trigger the execution of a predetermined third-party plug-in, causing the plug-in to generate a functional interactive element that can be combined with the interactive functionality 212 or provided separately in a different interactive element or component (e.g., another menu, panel, or graphic functional element) that is displayed alongside the interactive functionality 212 (e.g., which may be generated by a native plug-in, etc.).

[0053] According to an example, the interactive system 100 allows a user to provide input for creating text content on the canvas 122. For example, the interactive system 100 may include an interactive graphic design system for allowing a user to create various types of visual elements and content, including text content. The graphic design system may be implemented to include multiple modes, including a text entry mode. In some examples, when the text entry mode is implemented, the canvas interface 210 identifies one or more predetermined plug-ins 224, where one or both of the plug-ins 224 are automatically executed sequentially or repeatedly in response to a predetermined user input (e.g., a single alphanumeric keystroke). Examples of predetermined plug-ins include native program processes (e.g., a native spell checker), third-party or developer plug-ins (e.g., a spell checker for medical terms, prescriptions, etc.), or other examples as described below (see FIGS. 4A-4C ).

[0054] Thus, after each character input, the content processing interface 220 executes one or more plug-ins 224. One or both of the plug-ins may execute to identify the input for processing. For example, each plug-in 224 may generate instructions or parameters that cause the canvas interface 210 to identify a content item (e.g., a word) of the current content entry input 211 (e.g., a character) for the corresponding plug-in 224 to process. Thus, the content items processed by each plug-in 224 may be the same or different. For example, the canvas interface 210 may identify consecutive characters after a space character (e.g., [space][c][a][t]) as a result of instructions / parameters generated by one or both plug-ins 224 selected or otherwise designated to execute automatically, by default or in response to a user's content entry.

[0055] Alternatively, one or both plug-ins 224 may be executed, causing the canvas interface 210 to identify content to be processed by the respective plug-in. For example, based on parameters specified by the executing plug-in, the canvas interface 210 may identify a sentence or graphic element that embeds the text content.

[0056] The content processing interface 220 can execute the plug-ins 224 to generate, as corresponding output 223, visual elements that are displayed with the content processed by the respective plug-ins 224. For example, if the plug-in 224 is a spell checker, the output of the plug-in 224 can be in the form of an underline for misspelled words. Further by way of example, the plug-in 224 can be a different spell checker, e.g., with a dedicated library that differs from the library of the first plug-in. In such a case, the output of the plug-in 224 can be a second visual element (e.g., a second squiggly underline) that is visually different from the output of the first plug-in. Thus, the output 223 of the plug-in 224 can be specified by the respective plug-in and can further affect the appearance of the content on the canvas 122 (e.g., a corresponding type of text effect applied to the processed text content). In some variations, the output 223 does not change the content but supplements the output with additional visual elements. In variations, the plug-in may be executed to generate output that changes the content (e.g., words that appear on the canvas).

[0057] Additionally or alternatively, the content processing interface 220 executes to generate interactive features or elements that may be displayed on the canvas 122 (e.g., floating above the canvas 122) to display the output of each plugin. As described in other examples, the output may include, for example, decisions regarding the spelling of words, the grammar of identified text segments or other content segments. The output may be used to populate menus or interactive features 212, allowing the user to selectively view corrections, alternate recommendations, etc.

[0058] In examples, the canvas interface 210 and the content processing interface 220 implement processes that are repeatedly or continuously executed in response to user input. For example, the canvas interface 210 can capture a single text character input, and the content processing interface 220 can identify the corresponding text content (e.g., a character, a word containing the character, etc.) to use in connection with the execution of a selected plug-in 224. The canvas interface 210 and the content processing interface 220 can repeat the process for the next character entry, such that a spell check is performed on a series of characters until the characters complete a word (e.g., they may be separated by a space character, or the presence of a space character followed by a punctuation mark, etc.). The content processing interface 220 can similarly implement an automated process that repeatedly or continuously executes one or more plug-ins, such as from the plug-in library 250, to parse corresponding words (e.g., a series of characters not interrupted by a space character) as the user enters characters for the word. In variations, one or both (or more) of the plug-ins can be selectively executed by the user. For example, a first plug-in corresponding to a native spell checker may run continuously (e.g., in response to each character input by the user), and the user may interact with interactive functionality generated by content processing interface 220 to selectively run a second (or additional) plug-in from plug-in library 250. Thus, for example, the native plug-in may generate output that is a recommendation (e.g., as may be displayed in an interactive menu for the user), and the user may selectively run a second plug-in to determine synonyms for words or terms flagged by the first plug-in.

[0059] In an example, the content processing interface 220 includes logic for integrating output generated by multiple plug-ins. For example, the content processing interface 220 can implement logic for prioritizing the output of one plug-in or superseding the output of one plug-in with the output of another plug-in. Alternatively, the content processing interface 220 can combine the output of multiple plug-ins. For example, in an example where each plug-in corresponds to a particular type of spell checker, the output of each plug-in can result in a corresponding visual element indicating errors or alternatives for the user to consider. Each visual element can be different based on the parameters of the respective plug-in. Furthermore, each plug-in can generate menu items, data to add to the menu items, or other interactive features that can be displayed in a user interface panel or menu and that the user can interact with to allow the user to view each plug-in's output (e.g., view corrections, suggested actions, etc.). For example, subsequent interaction with a menu item can cause the canvas interface 210 to trigger a change to the content rendered on the canvas 122.

[0060] methodology Figures 3A and 3B illustrate an exemplary method for executing a plug-in associated with a content entry on a canvas, according to one or more embodiments. The exemplary method as shown in Figures 3A and 3B may be implemented in connection with an interactive system or platform such as those described in Figures 1A-1C. Accordingly, reference is made to elements of Figures 1A-1C and 2 for purposes of illustrating suitable components for performing the described steps or substeps.

[0061] At step 310, content input is detected. The interaction system may include native functionality, such as event listeners, that detect the entry of a particular type of content, such as text entry, or the entry of a particular graphic element, such as a frame. The interaction system 100 may be configured to detect such events, such as the entry of a particular type of content element. Furthermore, the interaction system 100 may be designed to be extensible through the use of plug-ins that can interface with the interaction system in real time while a user is using the interaction system 100 to create or modify a graphic design on a canvas. Each plug-in may correspond to a program that runs separately from the interaction system 100 to enhance the functionality of the interaction system 100.

[0062] In response to detecting content entry, one or more plug-ins are triggered to automatically execute in response to the content entry or another event in step 320. At least one of the plug-ins to be executed may be pre-selected, for example, by a user or administrator, to automatically execute in response to a particular type of event (e.g., detecting a content entry such as text entry).

[0063] Execution of the plugin results in one or more outputs. In step 330, the interactive system 100 includes a process that interfaces with the plugin to receive the plugin output, which may be provided on or along with the canvas. For example, the plugin output may be used to configure menu items that a user can select to perform additional operations, including modifying the content appearing on the canvas. Additionally or alternatively, the plugin output may be used to generate temporary content or visual elements that appear on the canvas, for example, in association with the content elements that provided the plugin input. Furthermore, the plugin output may be used to automatically modify user-generated content. For example, in the case of graphic design, the plugin output may automatically modify content written on the canvas by other users. For example, it may replace or modify words or phrases that appear as part of the canvas's content. It may modify or change the attributes of a graphic element (e.g., a frame), replace frames or other graphic elements, or add new content elements (e.g., terms, frames, and averages) as new content to the existing content on the canvas.

[0064] 3B, in step 340, the interactive system 100 allows a user to create, modify, and / or share user-created content provided on the canvas. In some examples, the user-created content can be in the form of graphic design, which can include graphic element objects as well as text content.

[0065] A user's content entry input on the canvas may be detected at step 350. As described in various examples, content entry detection may be performed by a native process or function of the interactive system 100, by another plug-in, and / or by a user-selected plug-in that is automatically executed in response to the content entry.

[0066] In step 360, in response to detecting the content entry input, the interaction system 100 can automatically trigger the execution of the user-selected or specified plug-in. In response, at least a first output generated by the execution of the plug-in is rendered into the user-created content. The interaction system can integrate the output of the executing plug-in in any one of several ways. For example, the interaction system 100 can generate a menu, menu item, or tool that reflects the output of the plug-in. Subsequent user interaction with the menu item or tool can cause the interaction system to integrate the output of the plug-in, for example, by writing content to the canvas and / or modifying existing content of the canvas to reflect the output of the plug-in. In other examples, other types of operations can be performed. In a variation, the output of the plug-in can be integrated by generating temporary content that is rendered into existing content of the canvas, such as existing content that reflects the triggering of the plug-in's execution. In another variation, the interaction system 100 can integrate the output of the plug-in by directly modifying the graphic design or user-generated content that appears on the canvas based on the output of the plug-in. [Example]

[0067] In some examples, the interactive system 100 can enable a plug-in that automatically executes in response to a predetermined event, such as the input of a character. The plug-in can utilize event listener functionality, which may be included in the native functionality of the interactive system. In other examples, the selected plug-in can execute using a default plug-in. In examples where events are related to a user's text content entry, the selected plug-in can enable the user to employ multiple types of spell checkers, each of which executes automatically in response to an event detected through a plug-in, a default plug-in, or the native functionality of the interactive system (e.g., event listener functionality). The selected plug-in can be created or configured for a specialized application (e.g., medical, legal, technical) or a specific type of user (e.g., corporate). Furthermore, in such examples, the spell checker can execute simultaneously with the native spell checker. Furthermore, the functionality of the native spell checker (e.g., identifying a range of characters to check, providing an event listener, etc.) can be used to leverage functionality and output that may be provided through a second plug-in (e.g., provided by a third party). Additional examples are provided below.

[0068] 4A-4B show exemplary interfaces that may be generated for a canvas in accordance with one or more embodiments. In the illustrated example, canvas 402 includes design elements 403, 404. Additionally, a toolbar menu 405 may be provided for canvas 402 to enable a user to create additional design elements and / or edit existing design elements on the canvas.

[0069] In the example of FIG. 4A , multiple plug-ins are automatically executed in response to a content entry of a particular type (e.g., text), where the content entry corresponds to a user entering a series of characters to form a single word or a phrase containing multiple words. Each executed plug-in can generate an interface overlay as output to enable the user to perform additional operations utilizing the detected content entry. In the illustrated example, the interface overlay corresponds to individual menu items 412, 414, and 416, each representing an operation or command that the user can select to perform. The menu items 412, 414, and 416 can comprise a menu structure 410. The menu structure 410 can be sized vertically or horizontally to accommodate the output of the individual plug-ins. In the illustrated example, three plug-ins are automatically executed to generate the corresponding menu items, illustrating that the size and content of the menu structure 410 can vary based on the plug-in the user selects to automatically execute.

[0070] In an example, the interactive system 100 may include a set of default plug-ins for use with particular types of content input (e.g., text input). For example, for text input, the interactive system's default plug-in may correspond to a spell checker. As described in the example, for each character input, the default spell checker plug-in executes by (i) determining whether a word has been entered (e.g., by checking whether the last character input is followed by a space or punctuation), (ii) determining whether the word is correctly spelled (e.g., by comparing the word input with a dictionary), and (iii) generating one or more outputs for the user. The outputs for the user may include a menu item 412 identifying the correctly spelled word (i.e., "donkey") and / or a visual indicator 415 overlaid on the canvas at or near the misspelled word. In the example of FIG. 4A , the user can interact with the menu item 412 and replace the misspelled word on the canvas with the identified word in the menu item 412. However, in a variant, the output of the default plug-in may automatically replace the misspelled word.

[0071] In an example, a user can select additional plug-ins to be automatically executed with the default plug-ins. In the example of FIG. 4A, the additional plug-ins can be executed based on the output of a default plug-in (e.g., a spell checker). Thus, in the illustrated example, the user-selected plug-in can be triggered to execute based on and / or using the output of the default plug-in. For example, menu item 414 shows the output of a scientific dictionary in which common words are selectively replaced with scientific terms. If a user misspells a word, the plug-in represented by menu item 414 can automatically execute by, for example, (i) using the output of the default plug-in to check a scientific dictionary for the appropriate scientific name of the misspelled word and (ii) if an appropriate scientific name is found, generating a corresponding menu item containing that name. Selecting menu item 414 replaces the word "doankey" with "Equus africanus asinus." Similarly, a second user-selected plug-in can receive the output from the spell checker ("donkey") and automatically translate the corrected word into another language (e.g., Spanish) specified by the user.

[0072] While the example of FIG. 4A shows a user-selected additional plug-in triggered to run using the output of the default plug-in, in variations, the additional plug-in can run without the output generated by the default plug-in. For example, if a word is not misspelled, the default plug-in can run to check the spelling of the word, but because the word was not misspelled, the default plug-in's output is not rendered. Thus, in examples, the additional user-selected plug-in can interface with the default plug-in to receive the checked word even if the word is spelled correctly. Furthermore, in some examples, the default plug-in can utilize the dialog system's native functionality for identifying word formations. In examples, the user-selected plug-in can interface with a native process and receive words detected by that process. In this way, the user-selected plug-in can run independently or without the output of the native plug-in. In additional variations, the user-selected plug-in can detect when a specific type of content is entered by the user (e.g., a word or phrase). The user-selected plug-in can implement a process that checks for a specific type of content in response to the user's content entry. For example, a user selection plug-in may check whether a word is formed after each character input by the user (e.g., by checking for characters between spaces, or between spaces and punctuation marks, etc.). Additionally, a user selection plug-in may include additional layers of logic for the purpose of filtering out content entries not intended for the plug-in. For example, a scientific dictionary plug-in may run after each character input and (i) detect whether a word is formed, (ii) detect whether the formed word indicates a noun, (iii) search a scientific dictionary for the presence of the detected word, and (iv) generate output if a match is found.

[0073] 4B shows a variation on the example of FIG. 4A in which a user-selected plugin executes automatically without the default plugin generating output on the canvas. As shown, in some examples, the user-selected plugin can execute independently of the default plugin (e.g., without receiving the plugin's output).

[0074] FIG. 4B also illustrates a variation in which the output of a user-selected plugin results in temporary content that does not change the basic design of the canvas. In the illustrated example, the output generated by the execution of a user-selected plugin can be provided, for example, as text content that temporarily overlays the detected word used as input to execute the plugin. In the specific example provided, the output of a Spanish translation plugin can be the generation of temporary content that provides a translation 417 of a phrase, with the translation updated with each new word detection. A scientific dictionary plugin can detect a noun and temporarily render the scientific term 419 for that word. In some examples, the user can interact with the temporary content and modify the content of the canvas 402. For example, the user can select a translation 417 to replace the phrase "This is a donkey."

[0075] Further, in some examples, a user-selected plug-in can automatically execute upon detection of a particular content entry to modify the content of the canvas 402. FIGS. 4C and 4D illustrate a sequence in which a detected content element or entry (e.g., a detected word) is replaced with an image, according to one or more examples. In such examples, a selected plug-in analyzes a user's text input (or alternatively uses a native process or the output of a default plug-in) to identify individual words and then replaces the detected word with an image, for example, from an image library. In the illustrated example, the word "donkey" is automatically replaced with a graphic or image depicting a donkey. Execution of the selected plug-in may include searching an image library for an image that matches the entered word and then replacing the word with the identified image. As a result, the design of the content can be changed. In other words, the identified image is written to change the graphic design of the canvas. In this manner, a selected plug-in can automatically execute, process the text input, and replace the text content (e.g., the word "donkey") with another content element (e.g., a graphic of a donkey). In a variant, the drawing can be presented as a temporary content element (e.g., either within a menu or as an overlay), which the user can then select to trigger content modifications to the canvas 402.

[0076] While various examples have been described in the context of automatically executing a plug-in in response to a content entry that is a sentence, in variations, a user-selected plug-in can be executed to analyze other types of content entries and perform an operation or function based on the detected content entry. For example, a plug-in can be executed to detect attributes (a “triggering content entry”) such as shape, fill or line color, line thickness, or other attributes or characteristics (e.g., a frame that spawns another object or frame). Once a triggering content entry is detected, the plug-in executes a function. The function can utilize input such as the triggering content entry. As described in other examples, functions performed by a plug-in can include (i) generating a menu or other overlay that allows a user to view or select the output of the selected plug-in, (ii) generating temporary content to cover the graphic design or content of the canvas (e.g., an image overlay) and, if necessary, allowing a user to select the overlay content as an insertion, replacement, or other modification to the content of the canvas, and / or (iii) automatically modifying the content of the canvas using the output of the selected plug-in.

[0077] As an illustrative example, a plugin can be designed to detect specific graphical elements, such as shapes or combinations of shapes and fill colors. Upon detecting a graphical element, the plugin performs a predetermined operation, such as (i) replacing the detected graphical element with a different graphical element, or (ii) modifying the detected graphical element to have different attributes. Specifically, the plugin can scan the graphical elements of a canvas (or underlying data structure) to identify fill colors of a specific hue. Upon detecting a specific hue, the plugin automatically replaces or modifies the hue with another hue. In this manner, for example, a company can configure an interactive system to automatically implement the plugin for brand protection purposes in the interactive system. Specifically, the plugin can detect offensive hues or hues that are counter to the company's branding in graphic design content elements and replace the hues with inoffensive or encouraged hues.

[0078] As another example, a plugin can be designed to detect a simplified design element, such as a circle, with a predetermined set of attributes (e.g., shape, fill, etc.). When a selected plugin detects a shape entered on the canvas, it performs an operation to replace the design element with an icon of a human head. The characteristics of the human head can be based, for example, on text content that appears on the canvas near a triggering content element (e.g., inline, before the design element). Alternatively, in the provided example, the plugin can execute to generate a menu or interface that allows a user to specify variables for a human head, such as an age range, gender, hair color, etc., and then replace the design element on the canvas with the resulting image.

[0079] Network Computer System 5 illustrates a computer system in which one or more embodiments may be implemented. Computer system 500 may be implemented, for example, on a server or combination of servers. For example, computer system 500 may be implemented as networked computer system 150 of FIGS. 1A-1C and utilized by plug-in subsystem 200 of FIG. 2.

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

[0081] The communication interface 550 allows the computer system 500 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 580 (wireless or wired). The computer system 500 can use the network link 580 to communicate with one or more computing devices, dedicated devices and modules, and / or one or more servers.

[0082] In an example, the processor 510 may execute service instructions 522 stored in the memory resources 520 to enable the network computer system to implement the network service 152 and operate as the network computer system 150 in an example such as that described with respect to Figures 1A-1C.

[0083] The computer system 500 may also include additional memory resources (“instruction memory 540”) for storing executable instruction sets (“interactive system instructions 545”) that are embedded in web pages and other web resources to enable user computing devices to implement functionality as described for the interactive system 100.

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

[0085] User Computer Device 6 illustrates a user computing device for use in one or more examples, as described. In examples, user computing device 600 can correspond to, for example, a workstation, desktop computer, laptop, or other computing system having suitable graphics processing capabilities to enable rendering of a design interface and graphic design work. In variations, user computing device 600 can correspond to a mobile computing device, such as a smartphone, tablet computer, laptop computer, VR or AR headset device, etc.

[0086] In the example, computing device 600 includes a central or main processor 610, a graphics processing unit 612, memory resources 620, and one or more communication ports 630. Computing device 600 can use main processor 610 and memory resources 620 to store and launch a browser 625 or other web-based applications. A user can operate browser 625 and use communication port 630 to access a network site of network service 152, where they can download one or more web pages or other resources 605 for network service 152 (see FIGS. 1A-1C and 2). Web resources 605 can be stored in active memory 624 (cache).

[0087] As illustrated by various examples, the processor 610 can detect and execute scripts and other logic embedded in web resources to implement the interactive system 100 (see FIGS. 1A-1C ). In some examples, some of the scripts 615 embedded in the web resources 605 can include GPU-accelerated logic executed directly by the GPU 612. The main processor 610 and the GPU can combine to render content 611 on the display component 640. The rendered design interface can include web content from the browser 625 as well as design interface content and functional elements generated by the scripts and other logic embedded in the web resources 605. By including scripts 615 executable directly on the GPU 612, the logic embedded in the web resources 605 can better execute the interactive system 100, including the plug-in subsystem 200, as illustrated by various examples.

[0088] conclusion Although examples are described in detail herein with reference to the accompanying drawings, it should be understood that the concepts are not limited to these detailed examples. Accordingly, it is intended that the scope of the concepts be defined by the following claims and their equivalents. Furthermore, it is contemplated that a particular feature described individually or as part of an example can be combined with other individually described features or with parts of other examples, even if the other features and examples do not mention that particular feature. Therefore, the absence of a description of a combination should not exclude the right to such a combination. [Explanation of symbols]

[0089] 10, 12, 600 user computer devices 80 Applications 100 systems 101 files 102 Program Interface 111 Data Structure Representation 118 Input Interface 120 rendering engine 121 Change Data 122, 402 canvas 125 Contents 150 Network Computer System 152 Network Services 155 Web Resources 157 System Commands 158 Site Manager 159 Workspace Representation 160 Service Components 163 Active Workspace File 164 File Store 200 Plugin Subsystem 210 Canvas Interface 211 Content Entry Input 212 Interactive Features 220 Content Processing Interface 223 Plug-in Output 224 Plugins 250 plugin library 255 plugin files 260 Developer Interface 403, 404 Design Elements 405 Toolbar Menu 412, 414, 416 menu items 415 Visual Indicators 417 Translation 419 Scientific terms 500 Computer Systems 510 processor 520 memory resources 522 Service Orders 540 instruction memory 545 Interactive System Instructions 550 Communication Interface 580 Links 600 user computer devices 605 Web Resources 610 processor 611 Contents 612 GPU 615 Script 620 Application Memory 624 active memory 625 browsers 630 communication port 640 Display Components

Claims

1. In a network computer system, one or more processors; a memory for storing an instruction set; Equipped with The one or more processors access instructions from the memory to: providing an interactive system that enables one or more users to create, modify, and / or share user-generated content on a canvas; detecting a user content entry input on the canvas; In response to detecting the content entry input, (i) automatically triggering execution of a plug-in implemented as a program executing separately from the interactive system, and (ii) rendering at least a first output produced by execution of the plug-in with the user-generated content; 2. A networked computer system that performs operations including:

2. 10. The networked computer system of claim 1, wherein providing the at least a first output comprises modifying a rendering of a content item that includes the content entry input.

3. 3. The network computer system of claim 2, wherein the content entry input comprises alphanumeric input, and modifying the rendering comprises modifying the appearance of a series of alphanumeric inputs rendered on the canvas, the series of alphanumeric inputs comprising the content entry.

4. The operation is providing user interface functionality related to said content entry input on said canvas; further comprising 2. The network computer system of claim 1, wherein providing the output comprises modifying the user interface functionality to include output generated by execution of the output.

5. 5. The networked computer system of claim 4, wherein providing said output includes supplementing a menu function with one or more options that said user can select to modify said user-generated content based on said output.

6. 5. The network computer system of claim 4, wherein providing the output includes generating a second user interface function that includes one or more elements generated by execution of the plug-in.

7. The operation is Maintaining a data store that identifies multiple plug-ins; and selecting one of the plurality of plug-ins to execute in response to the content entry input by default, preference, or user input; 10. The network computer system of claim 1, further comprising:

8. 2. The network computer system of claim 1, wherein the content entry input includes a keystroke, and the execution of the plug-in occurs in response to the detected keystroke.

9. 2. The networked computer system of claim 1, wherein the content entries correspond to textual content entered into the graphic design.

10. In response to triggering execution of the resulting plug-in, implementing one or more operations specified by the execution of the plug-in to identify input for processing by the plug-in; 10. The network computer system of claim 1, further comprising:

11. 2. The network computer system of claim 1, wherein b) comprises triggering a plurality of plug-ins; and c) comprises providing one or more outputs resulting from execution of said plurality of plug-ins.

12. 12. The network computer system of claim 11, wherein step c) comprises providing the first output generated by execution of the first plug-in and the second output generated by execution of the second plug-in.

13. 12. The network computer system of claim 11, wherein step c) comprises executing the first plug-in to obtain the first output, executing the second plug-in to obtain the second output, and selecting between the first output and the second output.

14. 12. The network computer system of claim 11, wherein step c) comprises executing the first plug-in to obtain the first output, executing the second plug-in to obtain the second output, and combining the first output and the second output.

15. 12. The networked computer system of claim 11, wherein the first output and / or the second output comprises a visual element rendered on the canvas.

16. The networked computer system of claim 2 , wherein the modified rendering of the content item does not modify the user-generated content on the canvas.

17. 1. A method of implementing a plug-in, the method being implemented by one or more processors; providing an interactive system that enables one or more users to create, modify, and / or share user-generated content on a canvas; detecting a content entry input of each of the one or more users on the canvas; In response to detecting each content entry input, (i) automatically triggering execution of a plug-in implemented as a program executing separately from said interactive system, and (ii) rendering at least a first output produced by execution of said plug-in with said user-generated content; A method comprising:

18. A non-transitory computer-readable medium storing instructions that, when executed by one or more processors, cause a computer system of the one or more processors to: providing an interactive system that enables one or more users to create, modify, and / or share user-generated content on a canvas; detecting a content entry input of each of the one or more users on the canvas; In response to detecting each content entry input, (i) automatically triggering execution of a plug-in implemented as a program executing separately from said interactive system, and (ii) rendering at least a first output produced by execution of said plug-in with said user-generated content; A non-transitory computer-readable medium for causing operations to be performed, including:

Images