CN105677371B

CN105677371B - Method and system for quickly generating software interface

Info

Publication number: CN105677371B
Application number: CN201610157950.4A
Authority: CN
Inventors: 张帅; 吴永
Original assignee: Goldencis Inc
Current assignee: Goldencis Inc
Priority date: 2016-03-18
Filing date: 2016-03-18
Publication date: 2020-05-19
Anticipated expiration: 2036-03-18
Also published as: CN105677371A

Abstract

The invention discloses a method for quickly generating a software interface, which comprises the following steps: step 1: modularizing UI interfaces, wherein different UI interfaces are created and managed by corresponding management modules; step 2: forming corresponding module and sub-function module configuration files according to the software interface, wherein the corresponding module and sub-function module configuration files follow the JSON standard format and comprise description information of the function modules and the sub-function modules; the description information of the sub-function module comprises display sequence fields of the sub-function interfaces in all sub-function interface sequences under the management module and interface description information fields of the sub-function interfaces; and step 3: and reading the configuration files of the modules and the sub-function modules, and finally realizing the drawing of the software interface according to the configuration files.

Description

Method and system for quickly generating software interface

Technical Field

The invention belongs to the field of computer software design, and particularly relates to a method and a system for quickly generating a software interface.

Background

The main function of the intranet safety control end software is to issue strategies and data statistics to the client.

The strategies are divided into two categories:

1. the strategy of no parameter: it includes the name of the policy, the execution period (during which time period this policy is executed), whether offline is supported (whether the policy is to be executed after the client is offline) and whether four elements are enabled

2. The strategy of participation: it includes the name of the policy, the execution period, whether to support offline, whether to enable policy parameters,

for example, in the policy of black and white list of web sites, the policy parameters include the black list or white list of web sites.

The elements displayed by the interface of the 'no-parameter strategy' are the same, and the 'parameter strategies' are different and all comprise the display elements of the interface of the 'no-parameter strategy'.

For the convenience of users, everyone can classify these interfaces according to categories, for example, three policy interfaces of "forbid sharing", "forbid installation procedure" and "forbid addition of users" are classified as "terminal security", i.e. we can also regard "terminal security" as a functional module, and the functional module includes three sub-functions of "forbid sharing", "forbid installation procedure" and "forbid addition of users".

Customers always have various requirements, and the customers can use the functions according to specific actual requirements, and can also put forward some improvement requirements, for example, sub-functions under some function modules are not needed by the customers, and the display is not required to be provided; also for example, as the frequency of use of certain functions varies, they wish to adjust the order of display of the lower interfaces to facilitate their use. These two columns can be said to be requirements that customers will often make. It is now common practice to make a "transcript" for a customer to meet their specific interface requirements if the customer makes such a request, and the general process is to make the customer request, feed back from the market sector, then develop and make the corresponding "special edition", then test, and finally provide the "special edition" to the customer.

In the conventional interface development mode, although the code is clear, the pertinence is strong, and interfaces with pertinence and different styles can be written at will, the interface development method has a plurality of defects on the development of large-scale software:

1. development efforts are large and each interface is written from scratch, including the writing and layout of interface elements, even though the appearances of the interfaces are similar.

2. The code maintenance cost is high, for example, if a certain interface is hidden or the display sequence of the interface is changed, the code file of each interface is also modified, and if a client needs to add a new function, the related interface is almost written from the beginning. The workload may be burdensome.

"proprietary" programs are voluminous and ultimately difficult to maintain.

Disclosure of Invention

The technical problem to be solved by the invention is to use the least code to generate the strategy interface quickly and simultaneously meet the special requirements of the group of users on the interface display.

The technical scheme adopted by the invention for solving the technical problems is as follows:

a method for quickly generating a software interface comprises the following steps:

step 1: the UI interfaces are divided in a modularized mode, different UI interfaces are created and managed by corresponding management modules, the sub-function management module provides a function interface of each UI interface, and the management module is responsible for creating and displaying the sub-function management modules in a specified mode;

step 2: forming corresponding module and sub-function module configuration files according to the software interface, wherein the corresponding module and sub-function module configuration files follow the JSON standard format and comprise description information of the function modules and the sub-function modules;

the description information of the sub-function module comprises display sequence fields of the sub-function interfaces in all sub-function interface sequences under the management module and interface description information fields of the sub-function interfaces;

and step 3: and reading the configuration files of the modules and the sub-function modules, and finally realizing the drawing of the software interface according to the configuration files.

Preferably, the step 3 specifically includes the following sub-steps:

31) generating an interface structure body of a management module and an example of a sub-function interface structure body according to the configuration files of the modules and the sub-function modules, and caching;

32) creating a corresponding QMODWidget window class instance for each management module interface structure instance, and transmitting the corresponding management module interface structure into the QMODWidget window class instance;

when initializing, the QModWidget instance creates and initializes a corresponding QFeatureWidget window class instance or a window class instance inherited from the QFeatureWidget for each sub-function interface structure instance under the module, and also needs to import a corresponding sub-function interface structure, wherein if there are multiple QFeatureWidget window class instances under the QModWidget instance, the QModWidget creates a Tab page control for managing the switching of the QFeatureWidget windows, and the display sequence corresponds to the sequence of the sub-function interface structures, which is defined by the description information of the sub-function modules in the above module and sub-function module configuration file.

Preferably, after the step 32), further comprising:

33) and generating a toolbar QMODToolBar class example for switching different management modules, wherein each button in the toolbar displays a module name and a corresponding display sequence, and the button display module name and the corresponding display sequence are defined by the description information of the function modules in the above module and sub-function module configuration files.

Preferably, after step 33), the method further comprises:

34) and generating a QMODContainer window class instance which is responsible for managing all QMODWidget instances, wherein the sequence number under the management module with the minimum default display sequence number is also the minimum sub-function interface, and the QMODContainer is communicated with the QMODToolBar, and when the toolbar switches the module, the QMODToolBar informs the QMODContainer window class instance to complete the specific switching action.

Preferably, the QFeatureWidget class example provides two virtual functions of onactive and onLeave, each sub-function window class of the QFeatureWidget class reloads the two virtual functions, and when the window is switched, the framework automatically invokes the two virtual functions of the sub-function window, thereby realizing the switching of the module or the sub-function interface.

Preferably, the hiding of the management module and the sub-function management module is realized by deleting interface description information fields in the configuration files of the modules and the sub-function modules.

Preferably, the display order between the modules is changed by changing the display order fields in the module and sub-function module configuration files.

A software interface rapid generation system, comprising:

the module setting unit is used for modularly dividing UI interfaces, and different UI interfaces are created and managed by corresponding management modules, wherein the sub-function management module provides a functional interface of each UI interface, and the management module is responsible for creating and displaying the sub-function management modules in a specified mode;

the configuration file setting unit is used for forming corresponding module and sub-function module configuration files according to the software interface, conforms to the standard format of JSON and comprises description information of the function modules and the sub-function modules;

and the drawing unit is used for reading the configuration files of the modules and the sub-function modules and finally realizing the drawing of the software interface according to the configuration files.

After the scheme is adopted, the code file does not need to be written for each interface, and only the UI interface is automatically generated according to the JSON configuration file and displayed in a designated mode, so that the method is quick and efficient, and the code maintenance amount is small.

Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. The objectives and other advantages of the invention will be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.

Drawings

The present invention will be described in detail below with reference to the accompanying drawings so that the above advantages of the present invention will be more apparent. Wherein the content of the first and second substances,

FIG. 1 is a schematic flow chart of a method for rapidly generating a software interface according to the present invention;

FIG. 2 is a schematic diagram of an embodiment of a method for rapid generation of a software interface according to the present invention;

FIG. 3 is a schematic structural diagram of the software interface rapid generation system of the present invention.

Detailed Description

The following detailed description of the embodiments of the present invention will be provided with reference to the drawings and examples, so that how to apply the technical means to solve the technical problems and achieve the technical effects can be fully understood and implemented. It should be noted that, as long as there is no conflict, the embodiments and the features of the embodiments of the present invention may be combined with each other, and the technical solutions formed are within the scope of the present invention.

The following explains the english abbreviations to which the present invention relates:

QT: a development framework for cross-platform C + + graphical user interface applications developed by the fancy technology in 1991.

Json JSON (JavaScript Object Notification) is a lightweight data interchange format. It is based on a subset of ECMAScript. JSON employs a text format that is completely language independent, but also uses conventions similar to the C language family (including C, C + +, C #, Java, JavaScript, Perl, Python, etc.). These properties make JSON an ideal data exchange language.

FUIGF: and the quick UI interface generation framework is used for quickly generating the UI interface according to the JSON configuration file.

Special edition: and according to the special requirements of each user, making a modified program on the standard edition program.

A functional module: and the interfaces are used for managing the same type of policy interfaces.

Subfunction: an interface for presenting and setting a policy.

The first embodiment is as follows:

as shown in FIG. 1, the invention discloses a method for quickly generating a software interface, which comprises the following steps:

step 1: modularly dividing UI interfaces, wherein different UI interfaces are created and managed by corresponding management modules (module widgets), wherein each UI interface is provided with a function interface by a sub-function management module (feature widget), and the management modules (module widgets) are responsible for creating and displaying the sub-function management modules (feature widgets) according to a specified mode;

the description information of the sub-function module comprises display Order (Order) fields of the sub-function interfaces in all sub-function interface sequences under the management module and interface description information (Feature) fields of the sub-function interfaces;

Namely, the invention mainly adopts a modularized thought, and sequentially draws the configuration files based on the JSON format to realize the rapid generation of the software interface, does not need to compile code files for each interface, only needs to automatically generate the UI interface according to the JSON configuration files and display the UI interface according to a specified mode, and has the advantages of rapidness, high efficiency and less code maintenance amount.

Example two:

the specific steps of the above embodiment are described with reference to this embodiment, wherein specifically, when performing rendering, the following sub-steps are specifically included:

32) creating a corresponding QMODWidget window class instance for each management module interface structure instance, and transmitting a corresponding management module interface structure (CMod) into the instance;

when initializing, the QModWidget instance creates and initializes a corresponding QFeatureWidget window class instance or a window class instance inherited from the QFeatureWidget for each sub-function interface structure instance under the module, and also needs to transmit a corresponding sub-function interface structure (CFeature), wherein if there are multiple QFeatureWidget window class instances under the QModWidget instance, the QModWidget creates a Tab page control responsible for managing the switching of the QFeatureWidget windows, and the display sequence corresponds to the sequence of the sub-function interface structures (CFeature), which is defined by the above modules and the description information of the sub-function modules in the sub-function module configuration file.

Moreover, the QFeatureWidget type example provides two virtual functions of onactive and onLeave, each subfunction window type of the QFeatureWidget type reloads the two functions, and when the window is switched, the framework can automatically transfer the two functions of the subfunction window, thereby realizing the switching of the module or the subfunction interface.

Example three:

to explain further, as shown in fig. 2, wherein in this example, the interface framework involved in this example is denoted by "FUIGF", which was developed using the QT technique.

It further comprises:

step 1: the UI interfaces are divided in a modularization mode, namely different UI interfaces are created and managed by corresponding management modules, the management modules are called 'module widgets', and subfunctions under the modules are called 'feature widgets'. The 'feature widget' provides a basic function interface which is necessary for each UI interface, and the 'module widget' is responsible for creating and displaying the 'feature widget' according to a specified mode.

The framework knows which modules are available, which interfaces are contained under each module, and the display order of the modules and the interfaces is controlled by a json file.

1.feature widget

2.module widget

A QMODToolBar class, implementing a toolbar for switching between different "module widgets".

JSON configuration file format (for example):

the above example is a module and sub-function module configuration file, which follows JSON standard format and thus can be made platform independent. The file totally describes three function modules (module widgets), namely three English words of 'homepage', 'devmgr' and 'policycenter', which are unique character codes (module names) of the three modules, and each module describes information of a plurality of sub-functions (features); wherein "homepage", "forbidbluetool" and "forbidwpd" are unique character encodings (sub-function names) of the sub-function interfaces.

And, the module description information:

order: the serial number of the module in the module sequence starts with 0, and the display sequence of the module is controlled by the serial number

Desc: description of this Module for interface display (support for internationalization)

Features: sub-function interface description information under the module

Subfunction interface description information:

order: the sequence numbers of the sub-function interfaces in all the sub-function interfaces in the management module are started with 0, and the display sequence of the sub-function interfaces is controlled by the sequence numbers

1, Desc: description of sub-functional interfaces for interface display (supporting internationalization)

The framework initialization process comprises the following steps:

1) and reading the JOSN configuration file to generate a management module and a sub-function interface structure body example and caching the management module and the sub-function interface structure body example.

Subfunctional interface architecture:

managing the module interface structure:

2) and creating and initializing a corresponding QMODWidget window class instance for each management module interface structure instance, and transmitting a corresponding CMod structure instance in the process.

3) When the QModWidget instance is initialized, a corresponding QFeatureWidget window class instance (or a window class instance inherited from the QFeatureWidget) is created and initialized for each sub-function interface structure instance under the module, and a corresponding CFeature structure instance is also required to be imported. If there are multiple QFeatureWidget window class instances under the QModWidget instance, the QModWidget will automatically create a Tab page control responsible for managing the switching of these QFeatureWidget windows, and the display order corresponds to m _ order in CFeature, which is taken from the "order" field of the subfunction description in json file.

4) A toolbar QModToolBar class instance is generated for switching before the different management modules, each button in the toolbar showing the module name defined by m _ strDesc in the CMod struct, taken from the "desc" field in the json file, the button display order of the toolbar corresponding to m _ order in the CMod struct, taken from the "order" field described by the module in the json file.

5) After the framework is initialized, one QMODContainer window class instance is responsible for managing all QMODWidget instances. And the sequence number under the management module with the minimum default display sequence number is also the minimum sub-function interface. When the QModToolBar toolbar switches the module, the QModContainer window class instance is notified, which completes the specific switching action.

Furthermore, as mentioned above, each sub-function window is an instance of the QFatureWidget subclass. The QFaacturetWidget base class provides two virtual functions of onActivate and onLeave, each sub-function window class of the QFaactuedWidget base class needs to reload the two functions, and when the window is switched, the framework can automatically transfer the two functions of the sub-function window.

The workflow of the method is that the initial state displays the A window by default, at the moment, the frame firstly calls an onactive function of the A window before the A window is displayed, when the A window is switched to the B window, the frame firstly hides the A window, then calls an onLeave function of the A window, then immediately calls an onactive function of the B window, and finally displays the B window. The onActivate function can be used as a creation work of the resource before the window is displayed, and the onLeave function can be used as a destruction work of the resource after the window is hidden.

In addition, when the module is hidden or the display sequence of the module is changed, the method comprises the following steps:

1) hiding the module: for example, to hide the peripheral management module, all descriptions for peripheral management by "desc" need to be deleted in the json file.

2) Changing the display sequence of the modules: it is only necessary to change the sequence number of the 'order' field under the module, and the sequence number is smaller and displayed more forward.

In addition, the display sequence of hiding the sub-function interface or changing the sub-function interface can be realized:

1) hiding the subfunction interface: for example, to hide the bluetooth disabled subfunction interface under peripheral management, only "forbidBluetool" { "order":0, "desc": bluetooth disabled "," standard ":1}, and" this deletion may be used.

2) And changing the display sequence of the sub-function interfaces: it is sufficient to change the sequence number of the "order" field under the subfunction, the smaller the sequence number, the more forward in the Tab page is displayed.

Compared with the prior interface development mode, the invention has the following two advantages:

1 management of functions and modules is very flexible, and can dynamically increase and decrease pages, adjust the relative order of function interfaces, and move a function from one module to another.

2, the maintenance cost of the code is extremely low, the addition and the reduction of a strategy page are very easy, if the strategy is a non-parameter strategy, no code change is needed, and only a parameter configuration page needs to be realized if the strategy is a parameter configuration strategy.

Example four:

corresponding to the above method embodiment, as shown in fig. 3, the present invention further provides a software interface rapid generation system, which is characterized by comprising:

the module setting unit is used for modularly dividing UI interfaces, and different UI interfaces are created and managed by corresponding management modules (module widgets), wherein each UI interface is provided with a necessary basic function interface by a subfunction management module (module widget), and the management modules (module widgets) are responsible for creating and displaying the subfunction management modules (feature widgets) according to a specified mode;

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects.

Finally, it should be noted that: although the present invention has been described in detail with reference to the foregoing embodiments, it will be apparent to those skilled in the art that changes may be made in the embodiments and/or equivalents thereof without departing from the spirit and scope of the invention. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for quickly generating a software interface is characterized by comprising the following steps:

and step 3: reading the configuration files of the modules and the sub-function modules, and finally realizing the drawing of a software interface according to the configuration files; the method specifically comprises the following substeps:

33) generating a toolbar QMODToolBar class instance for switching different management modules, wherein each button in the toolbar displays a module name and a corresponding display sequence, and the button display module name and the corresponding display sequence are defined by the description information of the function modules in the above module and sub-function module configuration files;

2. The method for rapidly generating the software interface according to claim 1, further comprising, after the step 33):

3. The method for rapidly generating a software interface according to claim 1, wherein two virtual functions of onActivate and onLeave are provided in the QFatureWidget instance, each of its sub-functional windows class is to reload the two functions, and when a window is switched, the framework automatically invokes the two functions of the sub-functional windows, thereby implementing the switching of the module or sub-functional interface.

4. The method for rapidly generating the software interface according to claim 1, wherein the management module and the sub-function management module are hidden by deleting interface description information fields in the configuration files of the modules and the sub-function modules.

5. The method for rapidly generating the software interface according to claim 1, wherein the display sequence between the modules is changed by changing the display sequence fields in the configuration files of the modules and the sub-function modules.

6. A software interface rapid generation system is characterized by comprising:

the drawing unit is used for reading the configuration files of the modules and the sub-function modules and finally realizing the drawing of the software interface according to the configuration files;

the method specifically comprises the following steps: 31) generating an interface structure body of a management module and an example of a sub-function interface structure body according to the configuration files of the modules and the sub-function modules, and caching;