Data intercommunication method and device based on prototype file and design file

Abstract

The invention discloses a data intercommunication method and device based on a prototype file and a design file, and the method comprises the steps that a design file layer is converted into a combination of an instance and a component set, the instance is a copy of the component set, and the instance retains the basic attribute and state information of the component set; a team sharing library is established, editing and deleting operation is carried out on the combination of the instance converted from the design file in the prototype file and the component set, newly-added operation is forbidden, and the prototype file and the design file share element resources and design assets; in the mutual copying and pasting operation, layer data of the prototype file and the design file are kept consistent, and editing operation is supported; the layers are pasted into the synchronization blocks in a cross-file mode, the layers are modified in the source file, the associated synchronization blocks automatically prompt updating, and design consistency is ensured. According to the method, the prototype file and the design file are mutually copied and pasted to exchange data, so that unified management and reuse of resources are realized.

Description

Technical Field

[0001] The present invention relates to the technical field of software design, and particularly to a data intercommunication method and device between a prototype file and a design file. Background Art

[0002] In the current product design process, prototype design and visual design are two important stages, usually independently completed by different tools. Prototype files are typically used for interaction design and user experience verification, while design files are used for visual representation and refined design of interface elements. The data of these two stages often need to be converted between different tools, resulting in low efficiency and information loss.

[0003] Most of the existing tool platforms fail to achieve seamless data intercommunication between prototype files and design files, lacking a resource sharing and synchronous update mechanism, which restricts the fluency of team collaboration and the consistency of design, making it difficult for prototype designers and visual designers to share component resources and design assets and to conduct unified management and reuse.

[0004] To solve the above problems, the present invention develops a data intercommunication method and device between a prototype file and a design file to exchange data through copy and paste operations between the prototype file and the design file, realizing unified management and reuse of resources. Summary of the Invention

[0005] In view of the above problems, a data intercommunication method and device between a prototype file and a design file are proposed to facilitate data exchange between the prototype file and the design file.

[0006] According to one aspect of the present invention, a data intercommunication method between a prototype file and a design file is provided, including:

[0007] Converting the design file layers into a combination of instances and component sets, where the instance is a copy of the component set, and the instance retains the basic attributes and status information of the component set;

[0008] Establishing a team shared library to edit and delete the combination of instances and component sets converted from the design file in the prototype file, and prohibiting new operations, where the prototype file and the design file share component resources and design assets;

[0009] In the copy and paste operations, the layer data of the prototype file and the design file are kept consistent and support editing operations;

[0010] Pasting the layer across files as a synchronization block, and when the layer in the source file is modified, the associated synchronization block is automatically prompted to be updated.

[0011] In an alternative approach, the basic attributes include fill, stroke, and position attributes, which are rendered and displayed in a consistent manner in the design file and the prototype file.

[0012] In an alternative approach, the method further includes:

[0013] When copying a layer from the design file to the prototype file, the property panel of the prototype file does not display the property settings of the design file;

[0014] When copying a layer from the prototype file to the design file, the property panel of the design file displays the property settings of the design file.

[0015] In an alternative approach, the prototype file and the design file respectively have different function sets;

[0016] Among them, the prototype file provides a first function set for product managers, and the first function set includes interactive elements and annotation notes;

[0017] The design file provides a second function set for designers, and the first function set includes design specifications, styles, masks, and flattening functions;

[0018] The first function set and the first function set have a common third function set, and the third function set includes a pen tool, a container, and a connection line.

[0019] In an alternative approach, the prototype file references the team library resources of the design file;

[0020] Among them, the team library resources include component resources and non-component resources. The component resources support inheritance and override of instances, and the non-component resources only support single reference.

[0021] In an alternative approach, the non-component resources include basic class resources and module resources;

[0022] Among them, the basic class resources include the smallest granularity resources, and the smallest granularity resources include shapes and buttons;

[0023] The module resources include product detail pages, intelligent filling resources, and icon resources.

[0024] In an alternative approach, the method further includes:

[0025] When viewing the layer pasted from the prototype file to the design file in the R & D mode or annotation mode, disable the interaction ability of the interactive elements in the layer, and only display the coordinate, height, and width information of the layer.

[0026] In an alternative manner, the layer icons in the left layer tree of the prototype design file and the design file are displayed consistently.

[0027] In an alternative manner, the method further includes:

[0028] The layer types in the prototype file include interactive components. When the interactive components are copied to the design file, placeholder layers corresponding to the layer types are automatically generated;

[0029] Among them, the placeholder layers graphically identify the original layers in the prototype file in the design file and provide links or quick operation entrances to jump back to the corresponding layers in the prototype file to achieve quick editing and modification of the prototype content.

[0030] According to another aspect of the present application, a data interoperability device based on a prototype file and a design file is provided, including:

[0031] A file conversion module for converting the design file into a combination of instances and a component set, where the instance is a copy of the component set, and the instance retains the basic attributes and status information of the prototype file;

[0032] A data interoperability module for performing mutual copy and paste operations on the prototype file and the design file, where the prototype file and the design file share component resources and design assets; in the mutual copy and paste operation, the layer types of the prototype file and the design file are consistent;

[0033] A combined editing module for editing and deleting the combination of instances and component sets converted from the prototype file in the design file and prohibiting new operations.

[0034] The solution provided in the above embodiments of the present invention converts the design file into a combination of instances and a component set, where the instance is a copy of the component set, and the instance retains the basic attributes and status information of the prototype file; performs mutual copy and paste operations on the prototype file and the design file, where the prototype file and the design file share component resources and design assets; in the mutual copy and paste operation, the layer types of the prototype file and the design file are consistent; edits and deletes the combination of instances and component sets converted from the prototype file in the design file and prohibits new operations. The present invention exchanges data through mutual copy and paste operations between the prototype file and the design file to achieve unified management and reuse of resources.

[0035] The above description is only an overview of the technical solution of the present invention. In order to better understand the technical means of the present invention, it can be implemented according to the content of the specification. And in order to make the above description, other purposes, features and advantages of the present invention more obvious and understandable, the following specific embodiments of the present invention are given. Description of the Drawings

[0036] By reading the following detailed description of the preferred embodiments, various other advantages and benefits will become clear to those of ordinary skill in the art. The drawings are only for the purpose of showing the preferred embodiments and are not considered to be a limitation of the present invention. Moreover, throughout the drawings, the same reference numerals are used to represent the same components. In the drawings:

[0037] Figure 1 A flowchart showing the data intercommunication method between a prototype file and a design file according to an embodiment of the present invention is shown;

[0038] Figure 2 A schematic diagram showing the creation of a prototype file and a design file according to an embodiment of the present invention is shown;

[0039] Figure 3 A schematic diagram of a design file according to an embodiment of the present invention is shown;

[0040] Figure 4 A schematic diagram showing the file import according to an embodiment of the present invention is shown;

[0041] Figure 5 A schematic diagram showing the functional structure of the apparatus for the data intercommunication method between a prototype file and a design file according to an embodiment of the present invention is shown. Detailed Embodiments

[0042] The exemplary embodiments of the present invention will be described in more detail below with reference to the drawings. Although the exemplary embodiments of the present invention are shown in the drawings, it should be understood that the present invention can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided so that the present invention can be more thoroughly understood and the scope of the present invention can be completely conveyed to those skilled in the art.

[0043] Before implementing the embodiments of the present invention, the technical terms or custom terms involved in the following text are uniformly explained here:

[0044] Component: It allows the UI to be divided into independent and reusable parts. In practical applications, components are often organized into a tree-like structure of nested layers.

[0045] Instance: An instance refers to a specific reference to a component. What is dragged out from the component list by the user or copied and pasted from the component is an "instance", rather than the body of the component.

[0046] The following is a detailed description of the data intercommunication method and device based on prototype files and design files proposed by the present invention through specific embodiments.

[0047] Embodiment 1:

[0048] Figure 1 The functional structure diagram of the data intercommunication method based on prototype files and design files according to the embodiment of the present invention is shown. Specifically, as Figure 1 shown, it includes the following steps:

[0049] Step S101, convert the design file layer into a combination of instances and component sets, where the instance is a copy of the component set, and the instance retains the basic attributes and status information of the component set.

[0050] In this embodiment, the elements in the design file are structurally processed and decomposed into reusable "component sets" and "instances" of the component sets. Similar to the relationship between classes and objects in object-oriented programming languages, the component set is equivalent to a class, and the instance is equivalent to an object. Converting the design file into a component set allows the reuse of the same visual elements in different design files, improving the efficiency and consistency of design. The component set is shared and modified by multiple designers, thus achieving seamless team collaboration and facilitating global style updates. The instance retains the basic attributes and status information of the prototype file, ensuring information consistency when copying and pasting between the prototype file and the design file, while allowing local settings for the instance. In addition, based on the component set, all instances using this component set can be quickly updated, greatly reducing the time and workload of iterative modifications, and making the management of design assets clearer through the relationship between the component set and the instance, facilitating maintenance and version control.

[0051] Specifically, analyze the layers in the design file (such as Figure 2 shown to establish a prototype file or a design file) to identify which layers can be defined as components (such as layers with reusable characteristics like buttons, navigation bars, cards, modal boxes, etc.). Extract the identified component layers and create corresponding component sets, and the component set stores the original visual information of the component (such as shape, color, font, layout, status, etc.).

[0052] Replace the component set in the design file with an instance of the component set. The instance records its corresponding component set ID and saves the specific attribute information of the current instance (such as the position, size, and local setting modifications of the instance). The instance retains the basic attributes of the prototype file (including attributes such as fill, stroke, and position) for data synchronization between the prototype file and the design file.

[0053] If both the prototype file and the design file have states (such as mouse hover, click, selection, etc.), map the state information in the prototype file to the component set states in the design file. For example, map the "button: pressed state" in the prototype file to the "pressed" state of the button in the design file component set.

[0054] In an alternative approach, the basic attributes include fill, stroke, and position attributes, which are rendered and displayed in a consistent manner in the design file and the prototype file.

[0055] In this embodiment, in the underlying data structures of the prototype file and the design file, a unified data format and unit are adopted for the fill, stroke, and position attributes. When copying elements from the prototype file to the design file, the fill, stroke, and position attributes in the prototype file are parsed and then converted according to the unified data structure required by the design file. When copying elements from the design file to the prototype file, corresponding parsing and conversion operations are performed to handle the compatibility of minor differences in attribute representations between different files. When data is transferred between the prototype file and the design file, ensure that the fill, stroke, and position attributes are rendered and displayed in exactly the same way in both files, avoiding design distortion caused by attribute differences.

[0056] In an alternative approach, the prototype file and the design file respectively have different function sets;

[0057] Among them, the prototype file provides a first function set for product managers, and the first function set includes interactive elements and annotation notes;

[0058] The design file provides a second function set for designers, and the first function set includes design specifications, styles, masks, and flattening functions;

[0059] The first function set and the first function set have a common third function set, and the third function set includes a pen tool, a container, and a connection line.

[0060] In this embodiment, the prototype file and the design file are oriented towards different user roles, so different function sets need to be provided. The prototype file is for product managers and is mainly used for quickly building interactive prototypes. The design file is for designers and is mainly used for visual refinement and standardization. Product managers focus on interaction logic and user flows (such as Figure 3 as shown in the left figure), and designers focus on visual performance and specifications (such as Figure 3The registration page shown on the right figure). Only the first function set and the third function set are displayed in the toolbar and operation interface of the prototype file, and only the second function set and the third function set are displayed in the toolbar and operation interface of the design file. The switching between function sets is realized through methods such as tab pages and sidebars, without the need to switch between different files. Different users only need to learn the functions they need, reducing the learning cost.

[0061] In an alternative manner, the prototype file references the team library resources of the design file;

[0062] Among them, the team library resources include component resources and non-component resources. The component resources support inheritance and overriding of instances, and the non-component resources only support single reference.

[0063] In this embodiment, the inheritance of components allows the creation of basic components, and the styles or behaviors in specific scenarios can be customized through overriding, bringing flexibility while maintaining consistency. The single reference of non-component resources ensures that they will not be modified incorrectly in the prototype. After modifying the component or non-component resources in the team library, each prototype using this resource will be automatically updated, saving a large amount of time for manual adjustment.

[0064] In an alternative manner, the non-component resources include basic class resources and module resources;

[0065] Among them, the basic class resources include the smallest granularity resources, and the smallest granularity resources include shapes and buttons;

[0066] The module resources include product detail pages, intelligent filling resources, and icon resources.

[0067] In this embodiment, by taking basic class resources (such as shapes and buttons) as separate management units, more refined control and reuse can be achieved. Modules such as product detail pages are reused in multiple prototypes, accelerating the prototype building speed and maintaining a consistent user experience. Through the hierarchical structure from the smallest granularity resources to basic class resources and then to module resources, more systematic design can be carried out to ensure the consistency of the design styles of team members.

[0068] Step S102, establish a team shared library, edit and delete the combination of instances and component sets converted from the design file in the prototype file, and prohibit new addition operations, where the prototype file and the design file share component resources and design assets.

[0069] In this embodiment, a team - shared library is created to centrally store and manage component sets, instances, and related component resources and design assets. Among them, the component set is component - set data converted from stored design files, the instance is component - set instance data used in stored prototype files, the component resources are stored component resources (such as pictures, icons, etc.), and the design assets include assets such as colors and font styles. The prototype file and the design file can be copied and pasted from each other, and they use the same component library and resources. Users can quickly adjust the layout and add elements in the prototype file, and then directly copy and paste them into the design file to achieve the conversion from a quick prototype to a high - fidelity design, and ensure that the copied and pasted elements can be correctly presented and edited in the target file, avoiding the confusion of the layer structure. For the instances (references to prototype components) and component sets (related prototype components) converted from the prototype file in the design file, users are allowed to perform editing and deletion operations, but are prohibited from directly adding new instances or component sets in the design file. That is, the ability of users to directly add prototype components in the design file is restricted, so as to ensure the one - way dependence of the design file on the prototype file and guarantee the unified management and reuse of components.

[0070] In an alternative approach, the method further includes:

[0071] When copying a layer from the design file to the prototype file, the property panel of the prototype file does not display the property setting items of the design file;

[0072] When copying a layer from the prototype file to the design file, the property panel of the design file displays the property setting items of the design file.

[0073] In this embodiment, the main purpose of the prototype is to demonstrate interactions and processes, rather than visual details. Hiding the properties of the design file when copying from the design file to the prototype avoids the prototype file from being too complex. According to the different copying sources (design file or prototype file), the property panel of the target file displays different setting items. When copying from the design file to the prototype file, the property panel of the prototype file does not display the property setting items of the design file, maintaining the simplicity of the prototype and avoiding the prototype being inconsistent with the design due to accidental modification of design properties. When copying from the prototype file to the design file, the property panel of the design file displays the property setting items of the design file, allowing users to perform more refined adjustments and edits (such as colors, fonts, shadows, borders, etc.).

[0074] In an alternative approach, the method further includes:

[0075] When viewing the layer pasted from the prototype file to the design file in the R & D mode or annotation mode, the interaction ability of the interactive elements in the layer is disabled, and only the coordinate, height, and width information of the layer is displayed.

[0076] In this embodiment, in the R & D or annotation mode, when the user views the layers pasted from the prototype file into the design file, the interaction capabilities of the interactive elements in the layer are disabled, and only layout information such as the coordinates, height, and width of the layer is displayed. That is, the prototype layer is made "static" for viewing the layout only and cannot be directly operated on.

[0077] In an alternative approach, the method further includes:

[0078] The layer types in the prototype file include interactive components. When the interactive components are copied to the design file, placeholder layers corresponding to the layer types are automatically generated;

[0079] Among them, the placeholder layers graphically identify the original layers in the prototype file in the design file and provide a link or a quick operation entry to jump back to the corresponding layers in the prototype file to enable quick editing and modification of the prototype content.

[0080] In this embodiment, when an interactive component (such as a dropdown menu) in the prototype file is copied to the design file, a placeholder layer is automatically generated. The placeholder layer graphically represents the original component in the design file and provides a link or a quick operation entry for the user to quickly jump back to the prototype file to edit and modify the corresponding component. That is, through a "soft link" - type reference method, the relevance between the design file and the prototype file is maintained, allowing the user to quickly return to the prototype file to directly modify the component without frequently switching between multiple files.

[0081] Step S103, in the mutual copy - paste operation, the layer data of the prototype file and the design file is kept consistent and supports editing operations.

[0082] In this embodiment, the layer data of the prototype file and the design file is always consistent, avoiding data inconsistency problems caused by manual copy - paste operations, and facilitating collaboration between designers and developers.

[0083] In an alternative approach, the layer icons in the left - hand layer trees of the prototype design file and the design file are displayed consistently.

[0084] In this embodiment, when viewing layers in the prototype design file and the design file, the icons displayed in the left - hand layer tree are consistent. That is, if a layer is represented by a certain icon (such as a button icon) in the prototype file, then when the icon layer (or instance) appears in the design file, the same icon is used in the layer tree. That is, the visual representation of the same type of layer in the layer tree in different files should be consistent. In addition, as Figure 4 shown, the import functions of the prototype design file and the design file are also supported.

[0085] Step S104, paste the layer across files as a synchronization block. When modifying the layer in the source file, the associated synchronization block is automatically prompted to be updated.

[0086] In this embodiment, through the synchronization block (i.e., placeholder), it is ensured that the same design elements in multiple files are consistent, avoiding differences caused by manual updates. After the source file is modified, an update prompt is automatically given, reducing the time for manual inspection and synchronization.

[0087] Specifically, store the data of the synchronization block in a format such as JSON or XML, which includes the attributes and styles of the layer and the reference information of the source file. Save the reference information of the source file (such as file path, ID of the synchronization block, etc.) in the target file. Link the synchronization block in the target file to the corresponding layer in the source file in a way similar to a soft link. Detect changes in the source file by listening to the API or polling at regular intervals. When it is detected that the source file has been modified, parse the synchronization block data in the source file and compare it with the synchronization block data in the target file. When it is detected that the synchronization block data in the source file has changed, send an update prompt to the target file and automatically update the synchronization block in the target file to the latest version of the source file.

[0088] The solution provided in the above embodiment of the present invention converts the design file into a combination of instances and component sets. Among them, the instance is a copy of the component set, and the instance retains the basic attributes and status information of the prototype file; perform mutual copy and paste operations on the prototype file and the design file, where the prototype file and the design file share component resources and design assets; in the mutual copy and paste operation, the layer types of the prototype file and the design file are kept consistent; perform edit and delete operations on the combination of instances and component sets in the design file that are converted from the prototype file, and prohibit new operations. The present invention exchanges data through mutual copy and paste operations between the prototype file and the design file, realizing unified management and reuse of resources.

[0089] Embodiment Two:

[0090] Figure 5 Shows a functional structure diagram of the data intercommunication method and device based on the prototype file and the design file according to the embodiment of the present invention. As Figure 5 shown, the device includes:

[0091] A file conversion module 501, configured to convert the design file layer into a combination of instances and component sets, where the instance is a copy of the component set, and the instance retains the basic attributes and status information of the component set;

[0092] The shared management module 502 is used to establish a team shared library, edit and delete the combination of instances and component sets converted from design files in the prototype file, and prohibit new operations. Among them, the prototype file and the design file share component resources and design assets;

[0093] The cross-file consistency module 503 is used to ensure that the layer data of the prototype file and the design file remains consistent during mutual copy and paste operations and supports editing operations;

[0094] The synchronous block update module 504 is used to paste the layer across files as a synchronous block. When the layer in the source file is modified, the associated synchronous block is automatically prompted to be updated.

[0095] In an optional manner, the basic attributes include fill, stroke, and position attributes, which are rendered and displayed in a consistent manner in the design file and the prototype file.

[0096] In an optional manner, the shared management module 502 is further used for:

[0097] When copying a layer from the design file to the prototype file, the property panel of the prototype file does not display the property setting items of the design file;

[0098] When copying a layer from the prototype file to the design file, the property panel of the design file displays the property setting items of the design file.

[0099] In an optional manner, the prototype file and the design file have different function sets respectively;

[0100] Among them, the prototype file provides a first function set for product managers, and the first function set includes interactive elements and annotation notes;

[0101] The design file provides a second function set for designers, and the first function set includes design specifications, styles, masks, and flattening functions;

[0102] The first function set and the first function set have a common third function set, and the third function set includes pen tools, containers, and connection lines.

[0103] In an optional manner, the prototype file references the team library resources of the design file;

[0104] Among them, the team library resources include component resources and non-component resources. The component resources support inheritance and override of instances, and the non-component resources only support single reference.

[0105] In an optional manner, the non-component resources include basic class resources and module resources;

[0106] Among them, the basic type of resources includes the smallest granularity resources, and the smallest granularity resources include shapes and buttons;

[0107] The module resources include product detail pages, intelligent filling resources, and icon resources.

[0108] In an alternative manner, the cross-file consistency module 503 is further configured to:

[0109] When viewing the layers pasted from the prototype file to the design file in the R & D mode or annotation mode, disable the interaction capabilities of the interactive elements in the layers, and only display the coordinate, height, and width information of the layers.

[0110] In an alternative manner, the layer icons in the left layer trees of the prototype design file and the design file are displayed consistently.

[0111] In an alternative manner, the sharing management module 502 is further configured to:

[0112] The layer types in the prototype file include interactive components. When the interactive components are copied to the design file, placeholder layers corresponding to the layer types are automatically generated;

[0113] Among them, the placeholder layers graphically identify the original layers in the prototype file in the design file, and provide links or quick operation entrances to jump back to the corresponding layers in the prototype file to achieve quick editing and modification of the prototype content.

[0114] The solution provided in the above embodiments of the present invention converts the design file into a combination of instances and a component set. Among them, the instance is a copy of the component set, and the instance retains the basic attributes and status information of the prototype file; mutual copy and paste operations are performed on the prototype file and the design file, where the prototype file and the design file share component resources and design assets; in the mutual copy and paste operations, the layer types of the prototype file and the design file are kept consistent; editing and deletion operations are performed on the combination of instances and component sets converted from the prototype file in the design file, and new addition operations are prohibited. The present invention exchanges data through mutual copy and paste operations between the prototype file and the design file to achieve unified management and reuse of resources.

[0115] The algorithms or displays provided herein are not inherently related to any particular computer, virtual system, or other device. A variety of general-purpose systems may also be used in conjunction with the teachings presented herein. The structure required to construct such systems will be apparent from the above description. In addition, embodiments of the present invention are not directed to any particular programming language. It should be understood that the teachings of the present invention described herein can be implemented in a variety of programming languages, and the description of a particular language above is for the purpose of disclosing the best mode of the present invention.

[0116] In the specification provided herein, numerous specific details are set forth. However, it can be understood that embodiments of the present invention may be practiced without these specific details. In some instances, well-known methods, structures, and techniques have not been shown in detail so as not to obscure the understanding of this specification.

[0117] Similarly, it should be understood that, in order to streamline the present invention and assist in understanding one or more of the various inventive aspects, in the above description of the exemplary embodiments of the present invention, the various features of the embodiments of the present invention are sometimes grouped together into a single embodiment, figure, or description thereof. However, the disclosed method should not be construed as reflecting an intention that the claimed invention requires more features than are expressly recited in each claim. Rather, as reflected in the following claims, the inventive aspects lie in less than all of the features of the single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into the detailed description, with each claim standing on its own as a separate embodiment of the present invention.

[0118] Those skilled in the art will appreciate that the modules in the devices in the embodiments can be adaptively changed and disposed in one or more devices different from the embodiments. The modules or units or components in the embodiments can be combined into one module or unit or component, and in addition, they can be divided into multiple sub-modules or sub-units or sub-components. Except that at least some of such features and / or processes or units are mutually exclusive, any combination can be used to combine all the features disclosed in this specification (including the accompanying claims, abstract, and drawings) and all the processes or units of any method or device so disclosed. Unless otherwise expressly stated, each feature disclosed in this specification (including the accompanying claims, abstract, and drawings) can be replaced by an alternative feature that provides the same, equivalent, or similar purpose.

[0119] In addition, those skilled in the art can understand that although some embodiments herein include certain features included in other embodiments rather than other features, the combination of features of different embodiments means that it is within the scope of the present invention and forms different embodiments. For example, in the following claims, any one of the claimed embodiments can be used in any combination.

[0120] Each component embodiment of the present invention can be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. Those skilled in the art should understand that a microprocessor or a digital signal processor (DSP) can be used in practice to implement some or all of the functions of some or all of the components according to the embodiments of the present invention. The present invention can also be implemented as a device or apparatus program (e.g., a computer program and a computer program product) for performing part or all of the methods described herein. Such a program implementing the present invention can be stored on a computer-readable medium, or can be in the form of one or more signals. Such signals can be downloaded from an Internet website, or provided on a carrier signal, or provided in any other form.

[0121] It should be noted that the above embodiments illustrate rather than limit the present invention, and those skilled in the art can design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in the claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The present invention can be implemented by means of hardware including several different elements and by means of a suitably programmed computer. In a unit claim listing several devices, several of these devices can be embodied by the same item of hardware. The use of the words first, second, and third, etc. does not denote any order. These words can be interpreted as names. The steps in the above embodiments, unless otherwise specified, should not be construed as limiting the order of execution.

Claims

1. A data intercommunication method between a prototype file and a design file, characterized in that: include: Converting the design file layer into a combination of an instance and a component set, wherein the instance is a copy of the component set and the instance retains basic properties and state information of the component set; Establishing a team shared library, editing and deleting the combination of instances and component sets converted from the design files in the prototype file, and prohibiting the addition of new operations, wherein the prototype file and the design file share component resources and design assets; In the mutual copy and paste operation, the layer data of the prototype file and the design file remain consistent and support editing operations; Paste layers across files as synchronized blocks. Modify the layers in the source file and the associated synchronized blocks will automatically prompt for updates.

2. The data intercommunication method based on the prototype file and the design file according to claim 1 is characterized in that: The basic properties include fill, stroke and position properties, which are rendered and displayed in a consistent manner in the design file and the prototype file.

3. The data intercommunication method based on the prototype file and the design file according to claim 2 is characterized in that: The method further comprises: When copying a layer from the design file to the prototype file, the property panel of the prototype file does not display the property setting items of the design file; When a layer is copied from the prototype file to the design file, the property panel of the design file displays the property setting items of the design file.

4. The data intercommunication method based on the prototype file and the design file according to claim 1 is characterized in that: The prototype file and the design file have different function sets respectively; The prototype file provides a first function set for product managers, the first function set including interactive elements and annotation notes; The design file provides a second set of functions for designers, wherein the first set of functions includes design specifications, styles, masks, and stitching functions; The first function set and the first function set have a common third function set, and the third function set includes a pen tool, a container, and a connecting line.

5. The data intercommunication method based on the prototype file and the design file according to claim 1 is characterized in that: The prototype file references the team library resource of the design file; The team library resources include component resources and non-component resources. The component resources support inheritance and overwriting of instances, while the non-component resources only support single reference.

6. The data intercommunication method based on the prototype file and the design file according to claim 5 is characterized in that: The non-component resources include basic class resources and module resources; Wherein, the basic class resources include minimum granularity resources, and the minimum granularity resources include shapes and buttons; The module resources include product details page, smart fill resources and icon resources.

7. The data intercommunication method based on prototype files and design files according to claim 1 is characterized in that: The method further comprises: When viewing a layer pasted from the prototype file to the design file in the R&D mode or the annotation mode, the interactivity of the interactive elements in the layer is disabled, and only the coordinates, height and width information of the layer are displayed.

8. The data intercommunication method based on prototype files and design files according to claim 1, characterized in that: The layer icons in the layer tree on the left side of the prototype design file and the design file are displayed consistently.

9. The data intercommunication method based on prototype files and design files according to claim 1, characterized in that: The method further comprises: The layer type in the prototype file includes an interactive component, and when the interactive component is copied to the design file, a placeholder layer corresponding to the layer type is automatically generated; The placeholder layer graphically identifies the original layer in the prototype file in the design file, and provides a link or shortcut entry to jump back to the corresponding layer in the prototype file to enable quick editing and modification of the prototype content.

10. A data intercommunication device based on a prototype file and a design file, characterized in that: include: A file conversion module, used for converting a design file layer into a combination of an instance and a component set, wherein the instance is a copy of the component set, and the instance retains basic properties and state information of the component set; A sharing management module, used to establish a team sharing library, edit and delete the combination of instances and component sets converted from the design file in the prototype file, and prohibit the addition of new operations, wherein the prototype file and the design file share component resources and design assets; A cross-file consistency module, used to keep the layer data of the prototype file and the design file consistent during the mutual copy and paste operation, and support editing operation; The synchronization block update module is used to paste layers across files as synchronization blocks. When a layer is modified in the source file, the associated synchronization blocks will automatically prompt for update.

Images