Autocomplete feature for code editor

HK40137501APending Publication Date: 2026-09-11FEGMA CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
HK62026126898
Authority / Receiving Office
HK · HK
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-06-21
Filing Date
2026-07-31
Publication Date
2026-09-11

Smart Images

  • Figure 00000000_0000_ABST
    Figure 00000000_0000_ABST
Patent Text Reader

Abstract

A computer system operates or is operable to maintain a data storage device that includes searchable information for a graphical design, where the searchable information includes text-based information associated with one or more graphs of the graphical design. In response to receiving one or more character entries, the computer system performs a matching operation to match a sequence of characters with terms and / or values of text-based information of one or more graphs of a set. The computer system predicts or determines a matching code line entry based on the terms, values, or a combination of one or more terms and one or more values. The computer system provides predicted or matched code line entries to a code editor in order to automatically complement portions of the code line entries by the predicted or matched code line entries.
Need to check novelty before this filing date? Find Prior Art

Description

(19) State Intellectual Property Office (12) Invention Patent Application (10) Application Publication Number (43) Application Publication Date (21) Application Number 202480045285.2 (22) Application Date 2024.06.21 (30) Priority Data 63 / 522,406 2023.06.21 US (85) PCT International Application Entering National Phase Date 2025.12.31 (86) PCT International Application Application Data PCT / US2024 / 035122 2024.06.21 (87) PCT International Application Publication Data WO2024 / 263990 EN 2024.12.26 (71) Applicant: Fegmar Inc. Address: California, USA (72) Inventors: E. Scherjord, O. Nelson, P. Thomas, T. Dunkaf, K. Peterson (74) Patent Agency: Beijing Panhua Law Firm 11336 Patent Attorney Liu Lingyun (51) Int.Cl. G06F 8 / 33 (2006.01) G06F 16 / 24 (2006.01) G06F 8 / 34 (2006.01) G06F 40 / 10 (2006.01) G06F 8 / 20 (2006.01) (54) Invention Title Auto-completion Feature for Code Editor (57) Abstract A computer system operates or is operable to maintain a data storage device, the data storage device including searchable information for graphic design, wherein the searchable information includes text-based information associated with one or more graphs of the graphic design. In response to receiving one or more character entries, the computer system performs a matching operation to match the character sequence with terms and / or values ​​of text-based information of one or more graphs in the set. The computer system predicts or determines matching line entries of code based on the terms, values, or a combination of one or more terms and one or more values. The computer system provides the code editor with predicted or matched line entries of code so that parts of the line entries can be automatically completed using the predicted or matched line entries.Claims (3 pages), Description (11 pages), Drawings (5 pages), CN 121488218 A 2026.02.06 CN 1 21 48 82 18 A 1. A computer-implemented method, the method comprising: maintaining a data storage device including searchable information for a graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; receiving a sequence of character entries via a code editor interface; performing a matching operation to match the character sequence with terms and / or values ​​of the text-based information of one or more graphs in the set; determining predicted or matched line entries of code based on the terms, values, or a combination of one or more terms and one or more values; and providing the predicted or matched line entries of code to the code editor to automatically complete portions of line entries of code using the predicted or matched line entries of code. 2. The computer-implemented method of claim 1, wherein the predicted or matched line entry comprises a text identifier of a graph in the set. 3. The computer-implemented method of claim 1, wherein the predicted or matched line entry corresponds to an attribute value of a graph in the set. 4. The computer-implemented method of claim 1, wherein receiving the portion of the line entry comprises: receiving the line entry via an application programming interface (API) through one or more networks; and wherein providing the predicted line entry comprises: transmitting the predicted or matched line entry via the API. 5. The computer-implemented method of claim 1, wherein the predicted or matched line entry is at least partially based on the text identifier of the matched graph. 6. The computer-implemented method of claim 1, wherein performing the matching operation comprises: determining a set of candidate line entries based on one or more terms and / or values ​​of the set, and selecting the predicted or matched line entry from the candidate set based on one or more weighting factors of the set of candidate line entries. 7. The method of claim 6, wherein the weighting factor is based on nodes or a graph of at least one line of code entry of the candidate group. 8. The method of claim 6, wherein the weighting factor includes the frequency or count of each term or value matching the one or more entries in the data storage device.9. The method of claim 6, further comprising: receiving a set of one or more additional characters for the partial character sequence; and wherein performing the matching operation comprises: narrowing down the range of the set of candidate code line entries based on the set of one or more additional characters. 10. The method of claim 1, wherein performing the matching operation comprises: determining a portion of the graphic design corresponding to the position of the code representation where the partial code line entry is located; and wherein the matching terms and / or values ​​are included in the determined portion of the graphic design. 11. The method of claim 1, wherein the predicted or matched code line entry includes an attribute identifier of the matched graph. Claims 1 / 3 Page 2 CN 121488218 A 12. The method of claim 1, wherein the predicted code or matched line entry includes values ​​based on attributes of the matched graph. 13. A computing system comprising: one or more processors; a memory for storing instructions; wherein the one or more processors store instructions for performing operations, the operations including: maintaining a data storage device including searchable information for a graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; receiving a sequence of character entries via a code editor interface; performing a matching operation to match the character sequence with terms and / or values ​​of the text-based information of one or more graphs in the set; determining predicted or matched line entries of code based on the terms, values, or a combination of one or more terms and one or more values; and providing the predicted or matched line entries of code to the code editor to automatically complete portions of line entries of code using the predicted or matched line entries of code. 14. The computer system of claim 13, wherein the predicted or matched line of code entry includes a text identifier of a graph in the set. 15. The computer system of claim 13, wherein the predicted or matched line of code entry corresponds to an attribute value of a graph in the set. 16. The computer system of claim 13, wherein receiving the partial line of code entry includes: receiving the line of code entry via an application programming interface (API) through one or more networks; and wherein providing the predicted line of code entry includes: transmitting the predicted or matched line of code entry via the API.17. The computer system of claim 13, wherein the predicted or matched line of code entry is at least partially based on the text identifier of the matching graph. 18. The computer system of claim 13, wherein performing the matching operation comprises: determining a set of candidate line of code entries based on one or more terms and / or values ​​of the set, and selecting the predicted or matched line of code entry from the candidate set based on one or more weighting factors of the set of candidate line of code entries. 19. The computer system of claim 18, wherein the weighting factors are based on the nodes or graph of at least one line of code entry in the candidate set. 20. A non-transitory computer-readable medium storing instructions, which, when executed by one or more processors of a computer system, cause the computer system to perform operations including: maintaining a data storage device including searchable information for a graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; receiving a sequence of character entries via a code editor interface; performing a matching operation to match the character sequence with terms and / or values ​​of the text-based information of one or more graphs in the set; determining predicted or matched line entries of code based on the terms, values, or a combination of one or more terms and one or more values; and providing the predicted or matched line entries of code to the code editor to automatically complete portions of line entries using the predicted or matched line entries of code. Claims 3 / 3 Page 4 CN 121488218 A Auto-completion Feature for a Code Editor

[0001] Cross-Reference to Related Applications This application claims priority to each of (i) U.S. Patent Application No. 18 / 750,594, filed June 21, 2024, and (ii) U.S. Provisional Patent Application No. 63 / 522,406, filed June 21, 2023, the entire contents of which are incorporated herein by reference. Technical Field

[0002] The examples described herein relate to an auto-completion feature for a code editor. Background Art

[0003] Software design tools are diverse in form and widely used.In the field of application user interfaces, for example, software design tools require designers to integrate the functional aspects of a program with aesthetic and even legal requirements to obtain a set of pages that form the user interface of the application. For a given application, designers often have many goals and requirements that are difficult to track.

[0004] Developers are often unfamiliar with the details of graphic design, which are often intricate and numerous. This unfamiliarity can be a source of developer inefficiency, as they need to carefully observe the graphic design, review the designer's notes, and keep these details in mind when writing code. The developer's task not only needs to be efficient, but the level of detail included in the graphic design can also make the developer's task prone to errors. For example, developers can easily misread pixel distances between objects, corner attributes, and other attributes that are difficult to see without careful observation. Brief Description of the Drawings

[0005] Figure 1 illustrates an example graphic design system according to one or more embodiments.

[0006] Figure 2 illustrates an example method for implementing an auto-completion feature for a code editor interface according to one or more embodiments.

[0007] Figures 3A and 3B illustrate examples of a code editor interface for implementing an auto-completion feature according to one or more embodiments.

[0008] Figure 4 illustrates another example of a code editor interface for implementing an auto-completion feature according to one or more embodiments.

[0009] Figure 5 illustrates a computer system on which one or more embodiments may be implemented.

[0010] Figure 6 illustrates a user computing device for use with one or more examples according to the description. Detailed Description

[0011] According to various examples, a data storage device is maintained, which includes searchable information for graphic design. The searchable information may include text-based information, including text identifiers, attributes, and attribute values ​​of a set of graphs constituting the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a certain type. Further, each graph may be associated with a set of attributes including text identifiers. A character sequence is received via the code editor interface. The character sequence corresponds to a portion of code line entries. A matching operation is performed to match the character sequence with terms and / or values ​​of one or more graphs in the set. Predicted code line entries are determined based on the matched terms and / or values. The predicted line entries of CN 121488218 A on page 1 / 11 of the specification are provided to the code editor so that partial line entries can be automatically completed using the predicted line entries.

[0012] In various examples, line entries correspond to terms, values, or combinations of terms and / or values.

[0013] One or more embodiments described herein specify methods, techniques, and actions performed by a computing device, performed programmatically or as computer-implemented methods.As used herein, “programmatically” means using code or computer-executable instructions. These instructions may be stored in one or more memory resources of a computing device. The steps performed programmatically may or may not be automatic.

[0014] 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, subroutine, part of a program, or a software or hardware component capable of performing one or more specified tasks or functions. As used herein, a “module” or “component” may exist independently of other modules or components on a hardware component. Alternatively, a module or component may be a shared element or process of other modules, programs, or machines.

[0015] Some embodiments described herein may typically require the use of computing devices, including processing resources and memory resources. For example, one or more embodiments described herein may be implemented wholly or partially on computing devices such as servers, desktop computers, cellular or smartphones, tablets, wearable electronic devices, laptops, printers, digital photo frames, network devices (e.g., routers), and tablet devices. Memory resources, processing resources, and network resources can all be used in conjunction with building, using, or performing any of the embodiments described herein (including by performing any method or by implementing any system).

[0016] Furthermore, one or more embodiments described herein can be implemented using instructions executable by one or more processors. These instructions can be carried on a computer-readable medium. The machines shown or described in the following figures provide examples of processing resources and computer-readable media on which instructions for implementing embodiments of the invention can be carried on and / or executed. Specifically, the numerous machines shown by embodiments of the invention include one or more processors and various forms of memory for storing data and instructions. Examples of computer-readable media include persistent storage devices, such as hard disk drives on personal computers or servers. Other examples of computer storage media include portable storage units, such as CD or DVD units, flash memory (such as flash memory carried on mobile phones, multifunction devices, or tablets), and magnetic storage. Computers, terminals, and network-enabled devices (e.g., mobile devices such as mobile phones) are examples of machines and devices that utilize processors, memory, and instructions stored on computer-readable media. Additionally, embodiments may also be implemented in the form of a computer program or a computer-available carrier medium capable of carrying such a program.

[0017] System Description FIG1 illustrates a graphical design system according to one or more embodiments.The graphical design system 100 (“GDS 100”) described with respect to FIG1 can be implemented in any of a variety of different computing environments, including as a device-side application, as a network service, and / or as a collaboration platform. In various examples, GDS 100 can be implemented using a web-based application 80 that executes on user device 10. In other examples, GDS 100 can be implemented using a dedicated web-based application. As an additional or alternative, one or more components of GDS 100 can be implemented as a distributed system, such that the processes described by the various examples execute on both a network computer (e.g., a server) and user device 10.

[0018] In various examples, GDS 100 includes processes executed by a web-based application 80 installed on computing device 10. The web-based application 80 can execute scripts, code, and / or other logic for implementing the functionality of GDS 100. Additionally, in some variations, GDS 100 may be implemented as part of a web service, wherein a web-based application 80 communicates with one or more remote computers (e.g., servers for the web service) to perform the processes of GDS 100.

[0019] In various examples, user device 10 includes a web-based application 80 that loads processes and data for implementing GDS 100 on user device 10. GDS 100 may include a rendering engine 120 that enables users to create, edit, and update graphic design files. Further, GDS 100 may also include a code integration subsystem that combines or otherwise integrates programming code, data, assets, and other logic for developing graphic designs as part of a production environment.

[0020] In some examples, the web-based application 80 retrieves programmable resources from a website for implementing GDS 100. As an additional or alternative, the web-based application 80 may also retrieve some or all of the programmed resources from a local source (e.g., local storage residing in computing device 10). In providing the functionality described with respect to GDS 100, the web-based application 80 may also access various types of datasets. These datasets may correspond to files and libraries, which may be stored remotely (e.g., on a server, associated with an account) or locally.

[0021] According to an example, a user operates the web-based application 80 to access a website, where programmed resources are retrieved and executed to implement GDS 100.Users can initiate a session to implement GDS 100 in order to view, create, and edit graphic designs and generate program code for implementing the graphic designs in a production environment. In some examples, users correspond to designers who create, edit, and refine graphic designs for subsequent use in a production environment.

[0022] In various examples, the web-based application 80 may correspond to commercially available browsers such as Google Chrome (developed by Google), Safari (developed by Apple), and Internet Explorer (developed by Microsoft). In such examples, the processes of GDS 100 can be implemented as scripts and / or other embedded code downloaded by the web-based application 80 from a website. For example, the web-based application 80 may execute code embedded in a web page to implement the processes of GDS 100. The web-based application 80 may also execute these scripts to retrieve other scripts and programmatic resources (e.g., libraries) from a website and / or other local or remote locations. By way of example, web-based application 80 can execute JavaScript embedded in HTML resources (e.g., web pages built according to HTML 5.0 or other versions provided by standards published by the W3C or WHATWG consortium). In other variations, GDS 100 can be implemented using a dedicated application (such as a web-based application).

[0023] GDS 100 may include processes represented by procedural interface 102, rendering engine 120, design interface 130, code interface 132, and program code resources 140. Depending on the implementation, these components may execute on user device 10, on a network system (e.g., a server or a combination of servers), or on both user device 10 and a network system (e.g., as a distributed process).

[0024] Procedural interface 102 includes processes for receiving and sending data for implementing components of GDS 100. Additionally, procedural interface 102 may be used to retrieve procedural resources and datasets from local or remote sources, which collectively include a user or user account workspace file 155. In the example, workspace file 155 includes one or more datasets (represented by "graphic design dataset 157") that represent corresponding graphic designs that can be rendered by rendering engine 120. Workspace file 155 may include one or more graphic design datasets 157 that collectively define a design interface. Graphic design dataset 157 may be constructed as one or more nodes arranged hierarchically.Each node may correspond to a set of corresponding properties and property values, which together provide information defining or otherwise describing the design element represented by the node. As an addition or variation, the graphic design dataset 157 may be constructed as a collection of graphs, where each graph corresponds to an object (e.g., a frame, image, text), a group of objects, or a particular type of object. In various examples, each graph corresponds to a separate section of the graphic design 135 that includes design elements or a set of objects. Further, in some examples, the graphic design dataset 157 may be constructed as a collection of cards, pages, or sections that organize the graphic design 135.

[0025] According to one aspect, the programming interface 102 also retrieves programmatic resources including an application framework for implementing the design interface 130. Design interface 130 can utilize a combination of local browser-based resources and / or web resources (e.g., application architecture) provided through programmatic interface 102 to generate interactive features and tools that can be integrated with the rendering of graphic design 135 on a canvas. Design interface 130 can enable users to view and edit aspects of the graphic design. Thus, design interface 130 can be implemented as a functional diagram on which the canvas on which graphic design 135 is provided.

[0026] Design interface 130 is capable of detecting and interpreting user input based on, for example, the location and / or type of the input. The location of the input can refer to a canvas or screen location (e.g., a tap) or the start and / or end location of a series of inputs. The type of input can correspond to, for example, one or more input types occurring on the canvas or design elements rendered on the canvas. These inputs can be associated with canvas or screen locations to select and manipulate design elements or portions thereof. Based on the canvas or screen location, user input can also be interpreted as input for selecting design tools, such as input provided through the application architecture. In implementation, design interface 130 may, for example, use a reference to the corresponding canvas to identify the screen location of user input (e.g., a "click"). Furthermore, design interface 130 may interpret user input actions based on the location of the detected input (e.g., whether the input location indicates a selection of a tool, an object rendered on the canvas, or an area of ​​the canvas), the frequency of input detected within a given time period (e.g., double-click), and / or the start and end positions of the input or series of inputs (e.g., the start and end positions of clicks and drags), and various other input types specified by the user through one or more input devices (e.g., right-click, screen tap, etc.).

[0027] In some examples, rendering engine 120 and / or other components utilize graphics processing unit (GPU) accelerated logic, such as accelerated logic provided by WebGL (Web Graphics Library) programs that execute Graphics Library Shader Language (GLSL) programs running on the GPU. In various variations, web-based application 80 may be implemented as a dedicated web-based application optimized to provide the functionality described by various examples. Further, web-based application 80 may vary based on user device type, which includes the operating system used by user device 10 and / or the appearance factors of the user device (e.g., desktop computer, tablet, mobile device, etc.).

[0028] In various examples, rendering engine 120 renders graphic design 135 through design interface 130 using graphic design dataset 157, wherein graphic design 135 includes graphic elements, attributes, and attribute values. Each attribute of a graphic element may include an attribute type and an attribute value. For objects, attribute types include shape, size (or dimensions), graph, type, color, line thickness, text size, text color, font, and / or other visual characteristics. Depending on the implementation, these attributes reflect the characteristics of a two-dimensional or three-dimensional design. Thus, the attribute values ​​of individual objects can define, for example, the size, color, positioning, layering, and visual characteristics of the elements rendered as part of the design.

[0029] The graphic design 135 can be organized by screen (e.g., representing a production environment computer screen), page (e.g., where each page includes a canvas on which the graphic design is rendered), and partition (e.g., where each screen includes multiple pages or screens). A user can interact with the graphic design 135 via the design interface 130 to view and edit aspects of the graphic design. The design interface 130 can detect user input, and the rendering engine 120 can update the graphic design 135 in response to the input. For example, a user can specify input that changes the view of the graphic design 135 (e.g., zooming in or out of the graphic design); and in response, the rendering engine 120 updates the graphic design 135 to reflect the view change. Users can also edit the graphic design 135. The design interface 130 can detect input, and the rendering engine 120 can update the graphic design dataset 157 representing the updated design. Additionally, the rendering engine 120 can also update the graphic design 135, where changes made by the user are immediately displayed to the user.

[0030] Collaborative Environment In various examples, GDS 100 can be implemented as part of a collaborative platform, where multiple users operating different computing devices located in various locations can view and edit the graphic design.As part of the collaboration platform, when a user edits a graphic design, the changes made by the user are implemented in real time on instances of the graphic design on the computer devices of other collaborating users. Similarly, when other collaborators make changes to the graphic design, these changes are also reflected in real time through the graphic design dataset 157. The rendering engine 120 can update the graphic design 135 in real time to reflect the changes made to the graphic design by the collaborators.

[0031] In an implementation, when the rendering engine 120 makes changes to the graphic design dataset 157, the corresponding change data 111 representing that change can be transmitted to the network system 150. The network system 150 can implement one or more synchronization processes (represented by the synchronization component 152) to maintain the network-side representation 151 of the graphic design 135. In response to receiving the change data 111 from the user device 10, the network system 150 updates the network-side representation 151 of the graphic design 135 and transmits the change data 111 to the user devices of other collaborators. Similarly, if another collaborator makes changes to an instance of the graphic design on their respective device, the corresponding change data 111 can be transmitted from the collaborator's device to the network system 150. The synchronization component 152 updates the network-side representation 151 of the graphic design 135 and transmits the corresponding change data 121 to the user device 10 to update the graphic design dataset 157. The rendering engine 120 then updates the graphic design 135.

[0032] Code Generation In various examples, GDS 100 includes a process for generating code data represented by program code resource 140 for the code representation 145 of the graphic design. Program code resource 140 may include a process for accessing the graphic design dataset 157 of the workspace file 155 and generating code data representing the elements of the graphic design. The generated code data may include production-executable instructions (e.g., JavaScript, HTML, etc.) and / or information (e.g., CSS (or Cascading Style Sheets), assets (e.g., elements from a library) and other types of data.

[0033] In some examples, the graphic design dataset 157 is constructed to define multiple graphs, each graph corresponding to one of an object, a group of objects, or a particular type of object. In a particular example, the graph type may include border objects, groups of objects, components (i.e., objects consisting of multiple objects reflecting state or other changes between instances), text objects, images, configuration logic that implements layout or position links between multiple objects, and / or other elements of a predetermined type. For each graph of the graphic design, the program code resource 140 generates a code dataset associated with or otherwise linked to the design elements. For example, each graph of the graphic design dataset 157 may include an identifier, and the program code resource 140 may generate a code dataset associated with the identifier of the graph for each graph.Program code resource 140 can generate code representation 145 such that code line entries and elements (e.g., lines of code, sets of executable information, etc.) of code representation 145 are associated with specific diagrams of graphic design 135. These associations can map code line entries of code representation 145 to corresponding design elements (or diagrams) of graphic design 135 (e.g., represented by graphic design dataset 157). Thus, each line of code in code representation 140 can be mapped to a specific diagram or design element of graphic design. Similarly, in various examples, each diagram or design element of graphic design 135 can also be mapped to a segment of code representation 145.

[0034] Code Representation Rendering In some examples, code interface 132 renders a structured representation of code representation 145 for production environment rendering of graphic design 135. For example, code interface 132 can visually divide the presentation of code representation 145 into separate segments, where separate areas display production environment executable code instructions (e.g., separate areas for HTML and CSS code). Further, the code specification page 5 / 11 9 CN 121488218 A interface 132 may include segments that visually identify assets used in the graphic design 135, such as design elements that are part of a library associated with a user's account.

[0035] The code interface 132 may implement a combination of native browser-based resources and / or web resources (e.g., application architecture) provided through the programmatic interface 102 to generate interactive features and toolsets for displaying the code representation 145. As described below by way of example, the code interface 132 may enable the individual selection of elements of the code representation 145 as input to allow selection or navigation to the represented design element on the design interface 130. For example, a user may select one or more of the following as input: (i) a line of code, (ii) a portion of the line of code corresponding to an attribute, or (iii) a portion of the line of code reflecting an attribute value. Furthermore, the user may also select programmatic code data displayed in different areas, different types of programmatic code (e.g., HTML or CSS), assets, and other programmatic data elements.

[0036] The code interface 132, used for viewing design elements, can detect user input for selecting a code element. In response to detecting user input for a specific code element, the code interface 132 can identify one or more related design elements (or figures) associated with that code element to the design interface 130. For example, the code interface 132 can identify a specific figure indicated by the user's selection input. The code interface 132 can indicate the identified figure or design element to the design interface 130, causing the design interface 130 to highlight, navigate to, or otherwise emphasize one or more design elements associated with the selected code element.In some examples, design interface 130 may visually indicate one or more design elements associated with a code element selected independently through code interface 132, or indicate them separately from other design elements of the graphic design. In this case, other design elements of the graphic design may be hidden, while the relevant design element is displayed in the window of design interface 130. In this way, when a user interacts with code interface 132, the user can easily distinguish the associated design element from other design elements of the graphic design.

[0037] Selecting a code to navigate to a design element Further, selecting a code element in code interface 132 may cause design interface 130 to navigate to a specific set of design elements identified by the selected code element. For example, code interface 132 may recognize a diagram selected by user input, and design interface 130 may navigate the view of graphic design 135 to the canvas location where the relevant design elements are provided. As an adjunct or variation, design interface 130 may navigate by changing the zoom level of the view to focus on the specific design element associated with the identified design element.

[0038] Design and Code Interface Synchronization In various examples, design interface 130 and code interface 132 can be synchronized with respect to the content displayed through each interface. For example, code interface 132 can be provided as a window that is displayed side-by-side or together with the window of design interface 130. In one aspect, code interface 132 displays code elements that form a portion of the code representation, wherein each code element is associated with a diagram or design element having a corresponding identifier. Then, design interface 130 uses the identifier of the diagram / design element to render design elements of the graphic design 135 that correspond to the code elements displayed by code interface 132.

[0039] Further, GDS 100 can implement a process for keeping the content of design interface 130 associated with the content of code interface 132. For example, if a user scrolls through code data displayed through code interface 132, design interface 130 can navigate or center the rendering of graphic design 135 to reflect the code elements visible through code interface 132. According to the description, design interface 130 and code interface 132 can utilize a common set of identifiers for figures or design elements, such as those provided by the graphic design dataset 157.

[0040] Modifying Graphic Design via Code Interface In various examples, a user of device 10 can modify the graphic design 135 by changing the code representation 145 using code interface 132. For example, the user can select a code segment of representation 145 displayed through code interface 132 and then change the attributes, attribute values, or other aspects of the code element. The input of changing code representation 145 can automatically change the corresponding design element of graphic design 135.Design interface 130 can identify and modify the diagram or design element of the modified code segment, and the change can be reflected in the graphic design dataset 157. In response, rendering engine 120 can update the rendering of graphic design 135 to reflect the changes made through code interface 132. In this way, developers can make real-time changes to, for example, the design interface to add, delete, or otherwise modify the diagram or design element (e.g., by changing attributes or attribute values).

[0041] Viewing and Modifying Code Elements Through Design Interface Additionally, in various examples, a user can select design elements of graphic design 135 by interacting with design interface 130. For example, a user can select or modify the diagram of graphic design 135, and design interface 130 can display the corresponding segment of code representation 145 via code interface 132. As an addition or variation, code interface 132 can highlight or otherwise visually distinguish the code element (e.g., line of code) associated with the identified design element from the rest of code representation 145. In this way, developers can easily inspect the code elements generated for a design element of interest by selecting a design element or a diagram corresponding to that design element in the design interface 130 and viewing the code generated for the selected element or diagram in the code interface 132.

[0042] Further, in various examples, users can edit the graphic design 135 by interacting with the design interface 130. The rendering engine 120 can respond to input by updating the graphic design 135 and the graphic design dataset 157. When the graphic design dataset 157 is updated, the program code resource 140 can update the code representation 145 to reflect this change. Further, the code interface 132 can highlight, accent, or otherwise visually indicate the code elements that have changed due to changes made to the graphic design 135 via the design interface 130.

[0043] The code editor automatically completes the code. The code editor corresponds to a human-computer interface that is optimized to enable users to write and edit program code (e.g., executable programs, routines, etc.). In some examples, GDS 100 includes resources for enabling the use of code editor 20 to utilize data from a workspace file 155 of a graphical design. Code editor 20 can be used to create and / or edit code representation 145 for implementing the graphical design 135 in a production environment.

[0044] In various examples, program code resource 140 may include a code generator for generating code and data representing the graphical design of workspace file 155. Program code resource 140 may include an application programming interface (API) 139 for communicating with an external source, such as providing code editor 20 to users of GDS 100. In various examples, automatically generated code may be used to generate code representation 145, and code editor 20 may be used to update code representation 145.In various variants, developers use code interface 132 to create and update code representation 145.

[0045] In various variants, code editor 20 may be equipped with GDS 100 (e.g., on user device 10). Further, updates to code representation 145 may be made based on changes made through code editor 20.

[0046] In some examples, code editor 20 may be implemented by a remote source or otherwise provided. API 139 may enable a communication channel in which various types of events are monitored and detected. For example, changes to code representation 145 may be detected and used to update the local instance of code representation 145 on user device 10. Additionally, user interactions with code editor 20 may also be detected via API 139. For example, various key entries 137 of user interaction with code editor 20 may be detected via API 139.

[0047] According to some examples, program code resource 140 may provide a search component for code editor 20. Search component 142 can respond to certain types of input, such as individual character entries 137 or a series of character entries 137. In response to receiving one or more character entries 137, search component 142 performs a search or match operation to identify text data associated with the graphic design specification 7 / 11 page 11 CN 121488218 A and feeds the response back to code editor 20. As described by some examples, search component 142 implements one or more search routines to match one or more character entries 137 corresponding to portions of code line entries. In response to detecting one or more character entries 137 (or sequences thereof), search component 142 performs a match operation to identify one or more matching entries in search results 141. Search results 141 may include one or more suggestions to code editor 20, each suggestion automatically completing a portion or the remainder of the code line entry in progress.

[0048] In some examples, graphic design system (GDS) 100 includes a searchable data storage device 159 based on or representing a graphic design dataset 157. For example, the searchable data storage device 159 may be based on or otherwise correspond to the graphic design dataset 157 and optimized for alphanumeric searches. For instance, at least a portion of the searchable data storage device 159 may be constructed to map sequences of character entries to descriptors of the graph and indexes of text-based attributes, as provided by the graphic design dataset 157 in its structured representation of the graphic design 135. The searchable data storage device 159 may also be updated concurrently with updates to the graphic design dataset 157, such that the searchable data storage device 159 includes recent edits to the graphic design 135.

[0049] In some examples, the searchable data storage device 159 identifies terms and / or values ​​of text-based information associated with graphs, nodes, or segments of the graphic design 135. These terms may include text identifiers (e.g., names of objects), attribute (or property) identifiers, and other text-based information (e.g., names and descriptors of nodes or graphs, etc.) that may be determined based on the graphic design dataset 157, and values ​​may include field or attribute values. The identified terms and / or values ​​may be associated with snippets, which are determined from, for example, a code repository 145 and / or automatically generated. In various variations, the identified terms and / or values ​​are associated with data used to generate the snippets. Thus, in various examples, the snippets comprise one or more lines of code, or portions of lines of code, which are integrated with (or may be integrated with) the code representation 145 of the graphic design 135. In this way, snippets can be generated to provide portions of executable code (e.g., for a production environment) as well as code that can be compiled by the code representation 145.

[0050] In response to receiving a character entry (or a sequence of character entries), search component 142 performs a search operation using searchable data storage device 159 to identify one or more matching terms or values. These matching terms and values ​​can be determined based on text-based information associated with one or more graphs or nodes of the graphic design dataset 157. Further, each matching term or value may be associated with or otherwise linked to one or more code snippets.

[0051] Search component 142 may return search results 141 to code editor 20 via API 139. Search results 141 may include predicted or matching code line entries that complete at least a portion of the code line that the user is entering (e.g., when entering character entry 137). As described by example, predicted or matching code line entries may reference or otherwise include matching identifiers or descriptors of graphs of graphic design 135. As an addition or variation, the predicted or matched line entry may reference or otherwise include attribute values ​​included with or determined by the graphic design dataset 157. Furthermore, additional descriptor or file-specific information may also be returned via the search operation.

[0052] As an addition or variation, the result 141 returned by the search component 142 may include multiple possible sets of line entries (i.e., "candidate line entry sets"). Further, the search component 142 may be configured to filter matching line entries from the candidate set using subsequent character entries. For example, for each character entry 137, the search component 142 may perform a search on the searchable data storage device 159 and return a candidate line entry set.For each subsequent character entry 137, the number of candidate entries decreases as the number of candidate entries matching the character entry sequence 137 decreases. Specification 8 / 11 pages 12 CN 121488218 A

[0053] In various examples, the line entries of the candidate set returned in response to search result 141 can be ranked to reflect the likelihood that each line entry of the candidate set is being referenced by one or more character entries of the user. The ranking can be based on a term or value matching a character entry (or more character entries) 137. Further, the ranking can also be based on one or more weights. In some examples, the ranking (or weight) can be based on the count of the number of times a specific term or value matching one or more character entries 137 appears in the searchable data storage device 159 and / or the graphic design dataset 157. In various variations, the ranking or weight can be based on the recency of the matching term or value. Further still, the ranking / weight can be based on context, such as information related to the graph or node that the developer is coding. Furthermore, in other variations, ranking may be based on code snippets associated with each matching term or value. Various other weights and methodologies may be used to rank the candidate set of search results 141.

[0054] Methodology Figure 2 illustrates example methods for implementing auto-completion features of a code editor interface according to one or more examples. Methods such as those described by the examples of Figure 2 may be implemented using the components and processes described by Figure 1. Thus, for ease of illustration, reference may be made to the elements of Figure 1.

[0055] In step 210, a searchable data storage device 159 is maintained for the graphic design. The searchable data storage device may include text-based information determined according to the set of graphs or nodes of the graphic design. The text-based information may include text identifiers, attribute (or property) identifiers, and attribute or property values ​​that constitute the set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a certain type. Further, each graph may be associated with a set of attributes including text identifiers and other descriptors. In some examples, the searchable data storage device 159 may also include code snippets or references to code snippets.

[0056] In step 220, one or more characters are received via code editor 20, wherein the received characters or character sequences may match or otherwise correspond to a portion of a code line entry. In various examples, the character sequences may correspond to portions of terms (e.g., names, identifiers, attribute types, etc.), values, commands, and / or expressions.

[0057] In step 230, a matching operation is performed to match the characters or character sequences with terms, values, or combinations of one or more terms and one or more values ​​in searchable data storage device 159.The matching values ​​of a set, or a combination of one or more matching terms and one or more matching values, may correspond to, for example, an identifier of a graph (e.g., a feature / attribute name), a descriptor, or an attribute / attribute value.

[0058] In step 240, matching or predicted line entries are determined based on one or more matching terms and / or one or more matching values ​​(such as a set of attributes of a matching graph). Matching line entries may be associated with one or more matching terms and / or one or more matching values. In various variations, one or more matching terms and / or one or more matching values ​​may be used to generate code snippets. Further, in various examples, matching or predicted line entries may include one or more matching terms, one or more matching values, or a combination of one or more matching terms and one or more matching values. In some variations, predicted line entries may include additional text, terms, or information, such as non-specific information or terms.

[0059] In step 250, predicted line entries are provided to code editor 20 as an optional feature. Once a user makes a selection, the predicted line entries can be used to automatically complete the user's partial line entries. Updates can, for example, update the code repository for implementing the graphic design 135 in a production library. Further, the code repository can also be used to update the code representation 145.

[0060] Example Specification 9 / 11 Page 13 CN 121488218 A Figures 3A to 3B and 4 illustrate examples of code editor interfaces implementing a code auto-completion feature according to one or more embodiments. The examples of Figures 3A, 3B, and 4 can be implemented using, for example, the graphic design system 100 of Figure 1 and / or according to methods such as those described by Figure 2.

[0061] Referring to Figure 3A, the code editor interface 300 receives a character entry 311 (e.g., 'pr') from a user (e.g., a developer). As described, a search component 142 performs a matching operation to match the character entry input 311 with a set of candidate entries, which are returned to and displayed by the code editor interface. In response to a partial line of code entry 311, the code editor interface 300 displays a set of candidate line of code entries. Candidate line of code entries may be displayed, for example, in a panel or space 320 below or adjacent to the line of code input 311. For each candidate line of code entry, the character entry 311 may be matched with a term 321 (e.g., 'price', 'product-name', 'placeholder', etc.) that forms part of the corresponding line of code entry 323. As described by other examples, candidate line of code entries (or fragments) may be suggestions used to influence the user's writing of code for implementing the graphic design 135 in a production environment.For example, a user can select candidate line entries from a recommendation set to complete a line segment of code that the user has started writing with character entry 137.

[0062] In the example of FIG3B, the code editor interface 300 is shown as automatically completing portions (or fragments) of line entries corresponding to, for example, matching terms. In the example shown, the auto-completion feature completes code fragment 331 by replacing “pr” (the user’s character entry) with “.product”. The user can accept the auto-completed fragment by, for example, providing selection input (e.g., the user pressing the ENTER or TAB key on their keyboard). The terms used in the auto-completion operation can correspond to, for example, identifiers of diagrams in graphic design.

[0063] Referring to FIG4, the code editor interface 300 receives one or more character entries (e.g., 'f', 'fo', ... or 'font') from the user. Search component 142 can match character entries with any of a plurality of candidate terms (e.g., 'font', 'font-family', 'font-size', etc.), where each of the matched terms corresponds to, for example, a feature type. Search component 142 can identify terms corresponding to one or more value types of one or more of the identified terms 343 (e.g., strings or identifiers) and combinations of attributes and values ​​of one or more of the identified terms (e.g., font-size: 34px). Matching candidate terms may include code snippets or lines of code (or portions thereof) displayed to the user in space 340. The user can select autocomplete by selecting one of the candidates in space 340.

[0064] Network Computer System FIG5 illustrates a computer system on which one or more embodiments may be implemented. Computer system 500 may be implemented on, for example, a server or a combination of servers. For example, computer system 500 may be implemented as network computing system 150 of FIG1.

[0065] 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 in memory resources 520, such as information provided by random access memory (RAM) or other dynamic storage devices for storing information and instructions executable by processor 510. Memory resources 520 may also be used to store temporary variables or other intermediate information during the execution of instructions by processor 510.

[0066] Communication interface 550 enables computer system 500 to communicate with one or more user computing devices via network link 580 (wireless or wired) through one or more networks (e.g., cellular networks). Using network link 580, computer system 500 can communicate with one or more computing devices, dedicated devices and modules, and / or one or more servers.

[0067] In various examples, processor 510 can execute service instructions 522 stored in memory resource 520 to enable the network computing system to implement network services and operate as network computing system 150.

[0068] Computer system 500 may also include additional memory resources ("instruction memory 540") for an executable instruction set ("GDS instruction 545") embedded with web pages and other web resources to enable user computing devices to implement functions such as those described by GDS 100.

[0069] Thus, the examples described herein relate to the use of computer system 500 to implement the techniques described herein. According to one aspect, the techniques are executed by computer system 500 in response to processor 510 executing one or more sequences of one or more instructions contained in memory 520. These instructions may be read into memory 520 from another machine-readable medium. Executing the sequence of instructions contained in memory 520 causes processor 510 to perform the process steps described herein. In various alternative implementations, hard-wired circuitry may be used in place of or in combination with software instructions to implement the examples described herein. Therefore, the described examples are not limited to any particular combination of hardware circuitry and software.

[0070] User Computing Device FIG. 6 illustrates a user computing device according to the description for use with one or more examples. In various examples, user computing device 600 may correspond to, for example, a workstation, desktop computer, laptop computer, or other computer system with graphics processing capabilities, which are adapted to enable rendering design interfaces and graphic design work. In various variations, the user computing device 600 may correspond to a mobile computing device, such as a smartphone, tablet, laptop, VR or AR headset, etc.

[0071] In various examples, the computing device 600 includes a central processing unit or main processor 610, a graphics processing unit 612, memory resources 620, and one or more communication ports 630. The computing device 600 may use the main processor 610 and memory resources 620 to store and launch a browser 625 or other web-based applications. The user can operate the browser 625 to access the website of the web computing system 150 using the communication port 630, where one or more web pages or other resources 605 of the web computing system (see FIG. 1) may be downloaded.Web resource 605 can be stored in active memory 624 (cache).

[0072] As described in various examples, processor 610 can detect and execute scripts and other logic embedded in the web resource to implement GDS 100 (see FIG. 1). In some examples, some scripts in script 615 embedded with web resource 605 may include GPU-accelerated logic executed directly by GPU 612. Main processor 610 and GPU can be combined to render an in-edit design interface (“DIUE 611”) on display component 640. The rendered design interface may include web content from browser 625 as well as design interface content and functional elements generated by scripts and other logic embedded with web resource 605. As described in various examples, logic embedded with web resource 605 can perform IGDS 100 better by including script 615 that can be executed directly on GPU 612.

[0073] Conclusion Although examples have been described in detail herein with reference to the accompanying drawings, it should be understood that these concepts are not limited to these precise examples. Therefore, the scope of these concepts is intended to be defined by the following claims and their equivalents. Furthermore, it should be understood that a particular feature described in various ways, or a particular feature described as an example, can be combined with other features or other examples described in various ways, even if the other features and examples do not mention the particular feature. Therefore, such undescribed combinations should not be excluded from rights. (See Figure 1 in the diagram below.)

Claims

1. A computer-implemented method, the method comprising: The maintenance data storage device includes searchable information for graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a certain type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; Receive character entry sequences via the code editor interface; Perform a matching operation to match the character sequence with terms and / or values ​​of the text-based information in one or more graphs in the set; The predicted or matching line of code entries are determined based on the terms, values, or a combination of one or more terms and one or more values; and The predicted or matched line entries are provided to the code editor so that the predicted or matched line entries can be used to automatically complete parts of the line entries.

2. The computer-implemented method as described in claim 1, wherein, The predicted or matched line of code entries include text identifiers of graphs in the set.

3. The computer-implemented method as described in claim 1, wherein, The predicted or matched line of code entries correspond to the attribute values ​​of the graph in the set.

4. The computer-implemented method as described in claim 1, wherein, Receiving the partial line of code entries includes: receiving the line of code entries via an application programming interface through one or more networks; and The code line entries that provide the prediction include: transmitting the predicted or matched code line entries through the application interface.

5. The computer-implemented method as described in claim 1, wherein, The predicted or matched line of code entries are based, at least in part, on the text identifiers of the matched graph.

6. The computer-implemented method as described in claim 1, wherein, Performing the matching operation includes: determining a set of candidate line entries based on one or more terms and / or values ​​of the set, and selecting the predicted or matched line entries from the candidate set based on one or more weighting factors of the set of candidate line entries.

7. The method of claim 6, wherein, The weighting factor is based on the nodes or graph of at least one line of code entry of the candidate group.

8. The method of claim 6, wherein, The weighting factor includes the frequency or count of each term or value that matches one or more entries in the data storage device.

9. The method of claim 6, wherein, The method further includes: receiving a set of one or more additional characters for the partial character sequence; and The matching operation includes narrowing down the range of candidate code line entries based on one or more additional characters in the set.

10. The method of claim 1, wherein, Performing the matching operation includes: Determine the portion of the graphic design corresponding to the location of the code representation where the partial code line entry is located; and The matched terms and / or values ​​are included in the determined portion of the graphic design.

11. The method of claim 1, wherein, The predicted or matched line of code entries includes attribute identifiers of the matched graph.

12. The method of claim 1, wherein, The predicted code or matched line entry includes values ​​of attributes based on the matched graph.

13. A computing system, the computing system comprising: One or more processors; The memory is used to store instructions; Wherein, the one or more processors store instructions for performing operations, the operations including: The maintenance data storage device includes searchable information for graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects or an object of a certain type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; Receive character entry sequences via the code editor interface; Perform a matching operation to match the character sequence with terms and / or values ​​of the text-based information in one or more graphs in the set; The predicted or matching line of code entries are determined based on the terms, values, or a combination of one or more terms and one or more values; and The code editor is provided with the predicted or matched line entries so that the predicted or matched line entries can be used to automatically complete parts of the line entries.

14. The computer system of claim 13, wherein, The predicted or matched line of code entries include text identifiers of graphs in the set.

15. The computer system of claim 13, wherein, The predicted or matched line of code entries correspond to the attribute values ​​of the graph in the set.

16. The computer system of claim 13, wherein, Receiving the partial line of code entries includes: receiving the line of code entries via an application programming interface through one or more networks; and The code line entries that provide the prediction include: transmitting the predicted or matched code line entries through the application interface.

17. The computer system of claim 13, wherein, The predicted or matched line of code entries are based, at least in part, on the text identifiers of the matched graph.

18. The computer system of claim 13, wherein, Performing the matching operation includes: determining a set of candidate line entries based on one or more terms and / or values ​​of the set, and selecting the predicted or matched line entries from the candidate set based on one or more weighting factors of the set of candidate line entries.

19. The computer system of claim 18, wherein, The weighting factor is based on the nodes or graph of at least one line of code entry of the candidate group.

20. A non-transitory computer-readable medium storing instructions, which, when executed by one or more processors of a computer system, cause the computer system to perform an operation comprising: The maintenance data storage device includes searchable information for graphic design, the searchable information including text-based information, the text-based information including terms and values ​​constituting a set of graphs of the graphic design, wherein each graph corresponds to an object, a group of objects, or an object of a certain type, and each graph is associated with a set of attributes, the set of attributes including text identifiers; Receive character entry sequences via the code editor interface; Perform a matching operation to match the character sequence with terms and / or values ​​of the text-based information in one or more graphs in the set; The predicted or matching line of code entries are determined based on the terms, values, or a combination of one or more terms and one or more values; and The code editor is provided with the predicted or matched line entries so that the predicted or matched line entries can be used to automatically complete parts of the line entries.