CN113010168B - User interface generation method based on scene tree - Google Patents
User interface generation method based on scene tree Download PDFInfo
- Publication number
- CN113010168B CN113010168B CN202110219455.2A CN202110219455A CN113010168B CN 113010168 B CN113010168 B CN 113010168B CN 202110219455 A CN202110219455 A CN 202110219455A CN 113010168 B CN113010168 B CN 113010168B
- Authority
- CN
- China
- Prior art keywords
- interface
- node
- tree
- interactive
- user interface
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Abstract
The invention discloses a user interface generating method based on a scene tree, which comprises the following steps: 1) determining the number of interfaces of a user interface, the appearance and the function of each interface according to the requirements of the user interface; 2) constructing an interface tree according to the information in the step 1); 3) selecting a node in the interface tree, and editing the graphic element on the interface corresponding to the node; each interface after editing has an exit or return interactive primitive; 4) selecting a node in the interface tree, entering a state transition diagram editing interface corresponding to the node, and editing the node; entering a state migration diagram editing interface of the node for the first time, drawing the node, a subtree node of the node and an exit or return interaction task of the node according to the interface tree, and generating a state migration diagram of the node; 5) and converting the edited interface tree into corresponding codes through a generation template of the target language, and compiling the codes to generate the user interface.
Description
Technical Field
The invention relates to a user interface generation method based on a scene tree, and belongs to the technical field of software.
Background
User Interfaces (UI) are becoming more and more important as software interfaces in the wave of the rapid development of information technology. The designer designs the user interface generally by manually drawing the general outline and requirements of the user interface according to the requirements and then refining the outline and requirements by an interface design tool. At present, the industry has many available user interface design tools, such as Axure, Adobe XD and the like, which can not only draw an interface prototype, but also set simple interactive actions; many online design tools also support multi-person collaboration, and more complex functions can be realized.
Designers design user interface prototypes (tools), which can cover the static interface requirements of users and can also realize some dynamic interaction requirements; but its business type requirement is often hard to be embodied. In addition, the work of the designer and the work of the software developer are independent of each other, and the developer usually performs secondary development or redesign using the designer-provided design prototype in the software life cycle, which results in an increase in the work engagement cost between different teams. In addition, most of the prior art and products are based on a mesh structure, which, although enriching the functions, increases the learning cost of the user and increases the workload.
The motivation of the invention is to find a method for quickly constructing a user interface with a dynamic interaction function, and by using the method, a designer can quickly construct a user interface meeting the user requirements, even prototype software which can be directly run.
Disclosure of Invention
Aiming at the defects of the prior art, the invention provides a user interface generation method based on a scene tree. By the method, a designer can complete a static interface prototype and can construct an application program with an interactive function; due to the introduction of the scene design method, the interfaces of the software are in a tree topology structure, the complexity of the software and the learning cost of a user are reduced, the user can concentrate on the design, and the workload of designers is reduced; the direct generation of target language code and the compilation of the functions of the application program can enable developers to reuse the work of software designers to the maximum extent.
The technical scheme provided by the invention is as follows:
a user interface generating method based on a scene tree comprises the following steps:
1) standardizing and documenting the user interface requirements to ensure that the user interface requirements conform to the definition of a target language grammar and determine the number of interfaces, the appearance and the function of each interface;
2) constructing an interface tree according to the information in the step 1), wherein each interface related to the user interface corresponds to one node in the interface tree, and establishing connection between interface nodes according to the jump relation between the interfaces;
3) selecting a node in the interface tree, and editing the graphic element on the interface corresponding to the node; each interface after editing has an exit or return interactive primitive;
4) selecting a node in the interface tree, entering a state transition diagram editing interface corresponding to the node, and editing the node;
the state transition diagram editing interface comprises a state transition diagram and the interface tree after the state transition diagram is reduced; entering a state migration diagram editing interface of the node for the first time, drawing the node, a subtree node of the node and an exit or return interactive task of the node according to the interface tree, and generating a state migration diagram of the node;
5) and converting the edited interface tree into corresponding codes through a generation template of the target language, and compiling the codes to generate the user interface.
Further, the state transition diagram comprises an interface jump branch and an interaction task branch.
Furthermore, the interface jump branch comprises a current interface node, a trigger condition node and a subtree node; when a user selects one interface jump branch and the interactive primitive of one node in the interface tree, establishing association between the interface corresponding to the selected interface jump branch and the interface corresponding to the selected node, and selecting one interactive primitive from the interactive primitives supported by the selected interactive primitive as a trigger condition.
Furthermore, the interaction task branch comprises a current interface node, a trigger condition node and an interaction task node, and each interaction task node is provided with an interaction task list for a user to select an interaction task; when a user selects one interactive primitive of the interactive task branch and one node in the interface tree, establishing association between the interface corresponding to the selected interactive task branch and the interface corresponding to the selected node, and selecting one interactive primitive from the interactive primitives supported by the selected interactive primitive as a trigger condition; and then binding the selected interactive graphic elements with the interactive tasks selected by the user at the interactive task nodes, and realizing the execution of the bound interactive tasks when executing the trigger conditions of the selected graphic elements.
Further, the method for constructing the interface tree comprises the following steps: establishing abstract graphic representation of each interface, editing the user interface and attribute information of each interface related to the user interface, and representing the user interface as an independent graphic element; and then establishing connection between interface nodes according to the jumping relation between interfaces to generate the interface tree.
Further, the interaction tasks in the interaction task list include an intra-interface interaction task and an inter-interface jump task.
Further, the interface tree is constructed through a user interface generating device; the user interface generating device comprises an interface tree defining module, an interface defining module, a user interface action defining module and a user interface generating module; the interface tree definition module is responsible for defining the number of interfaces in an interface tree corresponding to a user interface and the incidence relation among the interfaces; the interface definition module is responsible for constructing each interface in a graphical mode and laying out; the user interface action module is responsible for defining jump actions between interfaces and interactive actions executed by components in the interfaces according to the dynamic interaction requirements of each interface and by combining the incidence relation between the interfaces, binding an interactive mode triggered by the components with an interactive task and generating an interface tree; and the user interface generation module is responsible for converting the constructed interface tree into corresponding codes through a generation template of the target language.
Further, the user interface definition module comprises an interface definition module, an interface skip module and an interface interaction behavior binding module; the interface definition module is responsible for defining the component style and layout on the interface; the interface skip module is responsible for defining skip relation among interfaces; and the interface interaction behavior binding module is responsible for binding the interaction mode triggered by the component with the interaction task.
A server, comprising a memory and a processor, the memory storing a computer program configured to be executed by the processor, the computer program comprising instructions for carrying out the steps of the method described above.
A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the above-mentioned method.
The invention provides a user interface generation method based on a scene tree, and by utilizing the method, a generation device matched with the method and a storage medium, the generation efficiency of a user interface and the utilization rate of an interface generation result can be improved.
Firstly, determining the user interface requirement to be constructed according to the user requirement; determining a user interface definition meeting the definition of the custom language grammar according to the user interface requirement; defining a user interface based on the user interface definition, a user interface generating device (such as patent documents of publication No. CN112052002A, entitled "user interface generating method, device and medium based on declarative programming framework"; patent documents of publication No. CN111736834A entitled "user interface generating method, device and storage medium based on DSL"; and patent documents of publication No. CN111124398A entitled "user interface generating method, device, equipment and storage medium"), and built-in domain knowledge; and generating the code of the user interface according to the newly defined user interface, the target language of the user and the user interface generating device.
Further, the custom language grammar comprises: user interface, component (i.e., primitive), style, location, content, and interaction of the component.
Further, the user interface includes a plurality of interfaces; the interface includes a plurality of components; the interface comprises dynamic interaction tasks which are realized or not realized by the user interface generating device; the assembly comprises a base assembly and a composite assembly; the styles of the components comprise background colors, background pictures, border colors and border line types; the position comprises a relative position and an absolute position; the content comprises text character strings, pictures, streaming media files and the like; the interactive action of the component comprises an interactive mode triggered by the component and an executed interactive task, and corresponds to the scene action in the scene design method; the interaction tasks comprise an in-interface interaction task and an inter-interface jump task which meet the requirements of a user.
Further, the user interface generating apparatus includes an interface tree defining module, an interface defining module, a user interface action defining module, and a user interface generating module, as shown in fig. 4. The interface tree definition module is responsible for defining the number of interfaces in an interface tree corresponding to a user interface and the association between the interfaces, and is specifically represented as a jump relation between the interfaces, as shown in fig. 3; the interface definition module is responsible for defining user interface description according to user interface requirements and built-in domain knowledge, and specifically shows that the user requirements construct each interface in a graphical mode through components and are laid out as shown in FIG. 2; the user interface action module is responsible for defining jump actions between interfaces and specific interaction actions executed by components in the interfaces by combining the association (interface tree) between the interfaces according to the dynamic interaction requirements of each interface, and specifically represents that an interaction mode triggered by the components is bound with an interaction task, and as shown in fig. 6, an interface tree is generated; the user interface generation module is responsible for converting the currently constructed interface tree into corresponding codes through a generation template of the target language and determining whether to carry out operations such as compiling, packaging and the like according to the target language.
The component-triggered interaction mode refers to an event-triggered mode supported by the ubiquitous computer system, such as single click, long click, right click, double click, gesture and the like.
Further, the built-in domain knowledge comprises an interface design method, a model driven development method and a scene design method. The interface design method comprises component selection, interface layout, color matching and the like of an interface; the model driving development method refers to a basic model + plug-in model development method; the basic model is a framework of software metadata and basic functions and corresponds to the basic components; the plug-in module is a powerful software blood product built on a basic model and corresponds to the composite component. The scene design method comprises scene tree design, scene design and scene action; the scene tree corresponds to the user interface and reflects the tree-shaped jump relation among the interfaces; the scene corresponds to the interface, and the interface elements (components) of the current interface are presented; the scene actions correspond to dynamic interactive behaviors, and comprise jump between interfaces (scene migration) and interactive tasks in the interfaces (scene tasks).
Further, the storage medium of the present invention refers to software or hardware containing computer program instructions; the computer program instructions, when executed by a computer processor, implement a method for generating a user interface as provided by embodiments of the present invention, as shown in fig. 5.
Further, after the interface which meets the user interface requirement is developed, the interface is merged into the corresponding storage directory of the storage medium in a plug-in mode, and the finally generated executable program executes the actual interface instruction instead of the virtual method, so that the project meeting the user requirement is terminated.
Compared with the prior art, the invention has the following advantages:
1) a scene design method is introduced, so that the software complexity is reduced, and a user (a designer and the like) can concentrate the working gravity center on the design.
2) No matter whether a software developer realizes the development work of the functional requirements or not, as long as the interface specification of the functional requirements is well defined, a software designer can utilize the realized and unrealized interfaces (virtual tasks) to complete the whole demo development process.
4) Each user interface is regarded as a node, and the whole software is presented in a tree form; meanwhile, the state transition diagram with the current node as the center can fully express the relationship between the state transition diagram and the parent-child nodes and the interaction tasks thereof by using a concise subtree, and the state transition diagram of the current interface is displayed by using the diagram in the traditional mesh topology structure software, which is complicated.
Drawings
FIG. 1 is a schematic flow chart diagram of a user interface generation method provided in accordance with the present invention;
FIG. 2 is a schematic view of a user interface definition provided in accordance with the present invention;
FIG. 3 is a schematic diagram of a user interface scene tree provided in accordance with the present invention;
FIG. 4 is a schematic diagram of a user interface generating device provided in accordance with the present invention;
FIG. 5 is a schematic illustration of a storage medium usage provided in accordance with the present invention;
FIG. 6 is a schematic diagram of interface scene migration provided in accordance with the present invention.
Detailed Description
First, the user interface generating apparatus according to the present invention refers generally to a system that implements the functions and the built-in domain knowledge specification as shown in fig. 4, and does not refer specifically to a specific software.
The present invention will be described in detail below with reference to specific embodiments and drawings, which are targeted to C language.
The process of the invention is shown in figure 1, and comprises the following steps:
determining final user interface requirements according to user requirements;
standardizing and documenting user interface requirements so that the user interface requirements can conform to the definition of the custom language grammar;
defining a user interface through a user interface generating device, so that the appearance and the interactive action of each interface meet the requirements of the user interface;
and generating an object code file (.h and.c) by using the user interface generating device and the defined user interface, and generating the exe executable program by using a built-in compiling connection function.
In the user interface requirement standardization and documentation process, the number of interfaces, the appearance and the function of each interface are determined, and the dynamic interaction function is determined in the form of an interaction task list meeting the interface specification of the user interface generation device.
The definition of the user interface is realized by the user interface generating device, and the operation flow is as the first three stages in fig. 4, which are specifically as follows:
and defining an interface tree, namely drawing the interface and the interface association according to the determined user interface requirement, wherein the finally drawn interface tree is shown in figure 3. By using the user interface generating device implemented in this embodiment, abstract graphical representations of interfaces are sequentially established in an interface tree definition module in a manner of dragging components, and attribute information (such as interface names, task list group names, and the like) of the interfaces is edited; then, the connection between the interface nodes is established according to the jump relation between the interfaces, namely an interface tree is established.
And defining interfaces, namely drawing each interface by using the components according to the determined requirements, and setting the properties and styles of each component, as shown in FIG. 2. And entering an interface definition module corresponding to the interface definition module through nodes in the interface tree, creating, modifying or deleting components on the interface according to requirements, and each interface has to have a quitted or returned component according to specifications.
Defining user interface actions, namely setting interface jump tasks according to a tree structure of an interface tree and setting interaction tasks according to specific interaction requirements of each interface, and specifically comprising the following steps: the definition of the interface action is realized by entering a user interface action definition module corresponding to the node in the interface tree; and defining the interface actions of all nodes in the interface tree one by one. The user interface action definition of an interface is implemented by using a state transition diagram and a scaled interface of a current interface node as shown in fig. 6, and the specific implementation process is as follows: firstly, simultaneously selecting a certain interface jump branch (left side of the diagram) in the state transition diagram and zooming components in the interface to complete the task binding of the interface components and the branch; then, a trigger mode interaction component of the branch is long-clicked, and one of the trigger mode interaction components supported by the popped component is selected as a trigger condition, so that page skipping is completed through a certain action (trigger mode) of the component; then, setting a component binding and triggering mode for the exit/return branch; and finally, adding an interactive task branch which is used for completing a specific function on the right side of the figure according to the service requirement, sequentially completing the setting of the component binding and triggering modes, and selecting a specific interactive task from the popped task list by long-clicking the interactive task component.
At this time, both the static page requirement and the dynamic interaction requirement of the user interface are defined by the user interface generating device, and a weak association is established with the determined normalized interaction task list, as shown in fig. 5.
The generation of the user interface is to convert the customized form description of the defined user interface into a code of the target language through technical means such as data driving, template matching and the like, and determine whether to perform operations such as compiling, connection and the like according to the specific situation of the target language, for example, the compiling and connection are required when the C language is used as target guidance.
After the user interface generation operation, the generated code or the compiled file thereof should be operable, the layout and components of each interface can be displayed, the jump can be performed according to the tree-like relation between the interfaces, and the dynamic interaction task to be executed by the components on each interface can be executed.
Before developers realize all interfaces (or interactive tasks), the generated target code can only execute virtual tasks which are realized by the user interface generating device; after the developer finishes, corresponding supplement and replacement can be carried out on the corresponding storage medium, and then the user interface generation operation is executed again, so that the final target requirement can be realized.
The present invention is specifically described below by taking a target software as an example:
1) and according to the dynamic interaction task requirements and interface specifications of the user interface required by the target software, establishing an interaction task list corresponding to each interface, grouping and naming the interaction task lists, and storing the groups and the names into an xml interface document.
2) And constructing an interface tree of the target software by using a user interface generating device by adopting a top-down software design idea. As shown in fig. 3, each interface related to a user interface is edited in an interface tree editing interface, an abstract graphical representation of each interface of software is sequentially established by means of dragging components or sketches, and attribute information (such as interface names and task list grouping names) of the user interface and each interface related to the user interface is edited, and then connections between interface nodes are established according to a jump relationship between the interfaces, so as to construct an interface tree. The task list group name is derived from the xml document of step 1.
3) And selecting nodes in the interface tree, entering an interface editing interface corresponding to the nodes, and creating, modifying or deleting components on the interface according to requirements. Wherein each interface must have either a back-out or a back-in interaction component.
4) And selecting the nodes in the interface tree, and entering a state transition diagram editing interface corresponding to the nodes. The state transition diagram editing interface mainly comprises two parts, namely a state transition diagram interface and a reduced version interface. And when the state transition graph editing interface of the node is entered for the first time, the state transition graph automatically draws the current node, the subtree node and the exit (or return) interaction task according to the interface tree. The branches in the state transition diagram mainly have two categories, namely an interface jump branch and an interaction task branch.
The interface jump branch comprises three nodes, namely a current interface node, a trigger condition node and a subtree node; the interface jump branch can be edited only, and can not be added or deleted. The operation of this branch is mainly two, namely, establishing association and setting trigger conditions. The user selects the components in the branch and zooming interfaces simultaneously to establish the association between the two interfaces; one of the interaction primitives (events) supported by the selected interaction component is selected to be a trigger condition, such as a jump to another interface by a single operation of a button in the current interface.
The interaction task branch also comprises three nodes, namely a current interface node, a trigger condition node and an interaction task node. The interaction task branches have three operations, namely, establishing association, setting triggering conditions and binding the interaction task. The first two operations are the same as the interface jump branch. The binding interaction task operation pops up an optional interaction task list through operations such as right key or long click on an interaction task node, and the corresponding interaction task is selected to complete the setting; the content of the list is determined by the task list grouping attribute for the current interface in step 2. The practical meaning of the branch is that a certain interactive primitive (event) of the primitive (control) is executed by binding the primitive (control) on the current interface and the interactive task, and a certain interactive task is executed, for example, a background picture of the interactive task is changed by clicking a single machine operation of a button in the current interface.
5) And generating corresponding codes according to a preset template. And generating a corresponding code according to a preset template and the selected language.
6) And compiling the codes. If only the interface function task list is available, the corresponding function realization is not completed, the condition compilation can be carried out at the moment, and the interactive task in the generated application program can be fed back in a virtual function form of a character string; if the interface function library is ready, the function library can be linked for compilation in its entirety and all functions of the application can be used, as shown in FIG. 5.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents, improvements and the like that fall within the spirit and principle of the present invention are intended to be included therein.
Claims (7)
1. A user interface generating method based on a scene tree comprises the following steps:
1) determining the number of interfaces of a user interface, the appearance and the function of each interface according to the requirements of the user interface;
2) constructing an interface tree according to the information in the step 1), wherein each interface related to the user interface corresponds to one node in the interface tree, and establishing connection between interface nodes according to the jump relation between the interfaces;
3) selecting a node in the interface tree, and editing the graphic element on the interface corresponding to the node; each interface after editing has an exit or return interactive primitive;
4) selecting a node in the interface tree, entering a state transition diagram editing interface corresponding to the node, and editing the node; the state transition diagram editing interface comprises a state transition diagram and the interface tree after being reduced; entering a state migration diagram editing interface of the node for the first time, drawing the node, a subtree node of the node and an exit or return interactive task of the node according to the interface tree, and generating a state migration diagram of the node; the state transition diagram comprises an interface jump branch and an interaction task branch; the interface jump branch comprises a current interface node, a trigger condition node and a subtree node; when a user selects one interface jump branch and an interactive primitive of one node in the interface tree, establishing association between an interface corresponding to the selected interface jump branch and an interface corresponding to the selected node, and selecting one interactive primitive from interactive primitives supported by the selected interactive primitive as a trigger condition; the interactive task branches comprise current interface nodes, trigger condition nodes and interactive task nodes, and each interactive task node is provided with an interactive task list for a user to select an interactive task; when a user selects one interactive task branch and an interactive primitive of one node in the interface tree, establishing association between an interface corresponding to the selected interactive task branch and an interface corresponding to the selected node, and selecting one interactive primitive from interactive primitives supported by the selected interactive primitive as a trigger condition; then binding the selected interactive graphics primitive with the interactive task selected by the user at the interactive task node to realize executing the bound interactive task when executing the trigger condition of the selected interactive graphics primitive;
5) and converting the edited interface tree into corresponding codes through a generation template of the target language, and compiling the codes to generate the user interface.
2. The method of claim 1, wherein the interface tree is constructed by: establishing abstract graphic representation of each interface, editing the user interface and attribute information of each interface related to the user interface, and representing the user interface as an independent graphic element; and then establishing connection between interface nodes according to the jump relation between the interfaces to generate the interface tree.
3. The method of claim 1, wherein the interaction tasks in the interaction task list include intra-interface interaction tasks and inter-interface jump tasks.
4. The method of claim 1, wherein the interface tree is constructed by a user interface generation device; the user interface generation device comprises an interface tree definition module, an interface definition module, a user interface action definition module and a user interface generation module; the interface tree definition module is responsible for defining the number of interfaces in an interface tree corresponding to a user interface and the incidence relation among the interfaces; the interface definition module is responsible for constructing each interface in a graphical mode and laying out; the user interface action module is responsible for defining jump actions between interfaces and interactive actions executed by components in the interfaces according to the dynamic interaction requirements of each interface and by combining the incidence relation between the interfaces, binding an interactive mode triggered by the components with an interactive task and generating an interface tree; and the user interface generation module is responsible for converting the constructed interface tree into corresponding codes through a generation template of the target language.
5. The method of claim 4, wherein the user interface definition module comprises an interface definition module, an interface jump module, an interface interaction behavior binding module; the interface definition module is responsible for defining the component style and layout on the interface; the interface skip module is responsible for defining skip relation between interfaces; and the interface interaction behavior binding module is responsible for binding the interaction mode triggered by the component with the interaction task.
6. A server, comprising a memory and a processor, the memory storing a computer program configured to be executed by the processor, the computer program comprising instructions for carrying out the steps of the method according to any one of claims 1 to 5.
7. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method of one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110219455.2A CN113010168B (en) | 2021-02-26 | 2021-02-26 | User interface generation method based on scene tree |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110219455.2A CN113010168B (en) | 2021-02-26 | 2021-02-26 | User interface generation method based on scene tree |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113010168A CN113010168A (en) | 2021-06-22 |
| CN113010168B true CN113010168B (en) | 2022-07-26 |
Family
ID=76386535
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110219455.2A Active CN113010168B (en) | 2021-02-26 | 2021-02-26 | User interface generation method based on scene tree |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113010168B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117094530B (en) * | 2023-10-16 | 2024-02-20 | 国网浙江省电力有限公司金华供电公司 | Power grid supply chain index system management and control method and system |
| CN117149339B (en) * | 2023-10-27 | 2024-01-26 | 腾讯科技（深圳）有限公司 | User interface relation recognition method and related device based on artificial intelligence |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101464799A (en) * | 2009-01-16 | 2009-06-24 | 天津大学 | MPI parallel programming system based on visual modeling and automatic skeleton code generation method |
| US20090178021A1 (en) * | 2007-12-28 | 2009-07-09 | Federal Home Loan Mortgage Corporation (Freddie Mac) | Systems and Methods for Modeling and Generating Test Requirements for Software Applications |
| CN106687921A (en) * | 2014-09-02 | 2017-05-17 | 起元科技有限公司 | Specifying components in graph-based programs |
| CN110795071A (en) * | 2019-10-11 | 2020-02-14 | 国电南京自动化股份有限公司 | User interface design and code separation method supporting real-time data dynamic binding |
| CN111694563A (en) * | 2019-03-11 | 2020-09-22 | 西北大学 | Visual design system and method for user interface mode |
-
2021
- 2021-02-26 CN CN202110219455.2A patent/CN113010168B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090178021A1 (en) * | 2007-12-28 | 2009-07-09 | Federal Home Loan Mortgage Corporation (Freddie Mac) | Systems and Methods for Modeling and Generating Test Requirements for Software Applications |
| CN101464799A (en) * | 2009-01-16 | 2009-06-24 | 天津大学 | MPI parallel programming system based on visual modeling and automatic skeleton code generation method |
| CN106687921A (en) * | 2014-09-02 | 2017-05-17 | 起元科技有限公司 | Specifying components in graph-based programs |
| CN111694563A (en) * | 2019-03-11 | 2020-09-22 | 西北大学 | Visual design system and method for user interface mode |
| CN110795071A (en) * | 2019-10-11 | 2020-02-14 | 国电南京自动化股份有限公司 | User interface design and code separation method supporting real-time data dynamic binding |
Non-Patent Citations (3)
| Title |
|---|
| 一种基于模型驱动的笔式界面开发框架研究;陈明炫 等;《电子学报》;20110228;第39卷(第2期);268-274 * |
| 以交互为中心的Post-WIMP界面模型;秦严严 等;《软件学报》;20060430;第17卷(第4期);691-702 * |
| 基于混合输入的场景设计工具;仝青山 等;《软件学报》;20191231;第30卷;48-61 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113010168A (en) | 2021-06-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN113849165A (en) | Customizable low-code front-end development framework and method based on visual dragging | |
| US8170901B2 (en) | Extensible framework for designing workflows | |
| EP1643435B1 (en) | An extensible framework for designing workflows | |
| US10592211B2 (en) | Generation of application behaviors | |
| CN113010168B (en) | User interface generation method based on scene tree | |
| Barnett et al. | Bootstrapping mobile app development | |
| Da Silva et al. | Integration of RE and MDE paradigms: the ProjectIT approach and tools | |
| Chatty et al. | Revisiting visual interface programming: creating GUI tools for designers and programmers | |
| CN111625226A (en) | Prototype-based human-computer interaction design implementation method and system | |
| Beuvens et al. | Designing graphical user interfaces integrating gestures | |
| JP2013518321A (en) | Pattern-based user interface | |
| CN101727327A (en) | Development method for visual JSP interface based on GEF technology | |
| Sukaviriya et al. | User-centered design and business process modeling: cross road in rapid prototyping tools | |
| Zdun et al. | Reusable architectural decisions for DSL design: Foundational decisions in DSL development | |
| Bishop | Multi-platform user interface construction: a challenge for software engineering-in-the-small | |
| Aghaee et al. | Live mashup tools: challenges and opportunities | |
| CN113934429A (en) | Design draft conversion method and device, computer equipment and storage medium | |
| CN116909553A (en) | Page online development and local compiling operation system | |
| CN101303663A (en) | Simulation test method for digital set-top box software development | |
| Derezinska et al. | Tracing of state machine execution in the model-driven development framework | |
| Sun et al. | A demonstration-based model transformation approach to automate model scalability | |
| Zdun et al. | Reusable architectural decisions for dsl design | |
| Pellens et al. | A development environment using behavior patterns to facilitate building 3d/vr applications | |
| CN114564195A (en) | Secondary development method of cloud CAD platform based on B/S architecture | |
| Leite et al. | Designing and executing software architectures models using SysADL Studio |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |