WO2018035686A1

WO2018035686A1 - Graphical user interface gui rendering method and apparatus

Info

Publication number: WO2018035686A1
Application number: PCT/CN2016/096264
Authority: WO
Inventors: 陈西克; 李荣辉
Original assignee: 中兴通讯股份有限公司
Priority date: 2016-08-22
Filing date: 2016-08-22
Publication date: 2018-03-01

Abstract

A graphical user interface GUI rendering method and apparatus, the method comprising: before compiling a compiler program used for rendering a GUI, acquiring parameters used for rendering the GUI by means of parsing markup language files used for rendering the GUI (S102); compiling the acquired parameters into the compiling program (S104); and rendering the GUI by means of running the compiling program having the compiled parameters (S106). The present method and apparatus solve the problem in the prior art of the low efficiency of program execution as a result of the need to parse the parameters for rendering the GUI during the compiling process, and thereby achieve the effect of improving the efficiency of the execution of the GUI rendering program.

Description

Graphic user interface GUI drawing method and device

Technical field

The present invention relates to the field of communications, and in particular to a method and apparatus for drawing a GUI of a graphical user interface.

Background technique

The embedded graphical user interface GUI system is a key technology in embedded systems. Its performance and interface quality are directly affecting the user experience of embedded products. However, due to the limited available mechanisms and available underlying mechanisms provided by the operating system, the development of GUIs on embedded systems is not as easy and convenient as the development of applications on PC platforms. In this way, selecting a complete and suitable GUI support system for target embedded products with different hardware configurations and embedded operating systems becomes a challenging problem.

At present, there are two main ways to develop GUI on embedded systems: one is to develop an existing GUI library for a specific embedded system, such as Microsoft's WinCE, TrollTech's Qt and GNU's GTK+. The approach can generally be based on a GUI library to provide a complete solution and application. However, the general GUI library is relatively large, it needs to be tailored and personalized when it is used, and often costs extra to obtain software license. Second, the embedded graphics middleware specially designed by the developer for embedded systems. Pieces such as MiniGUI, SwellSoftware's PEG and TilconSoftware's Tilcon products. Although the GUI of this type occupies less resources, it is easy to meet the real-time and personalized requirements of the embedded system. However, this method is generally maintained by a professional company, and is only suitable for an embedded system with a single function, and has the disadvantage of insufficient expansion.

In response to the above problems, no effective solution has been proposed yet.

Summary of the invention

The embodiment of the invention provides a method and a device for drawing a graphical user interface GUI, so as to at least solve the problem that the related art needs to parse the parameter set to draw the GUI during the compiling process, resulting in low program execution efficiency.

According to an embodiment of the present invention, there is provided a method for drawing a GUI of a graphical user interface, comprising: parsing a markup language file for drawing the GUI, and acquiring the compiler before compiling the GUI for drawing the GUI The parameters of the GUI are drawn; the obtained parameters are compiled into the above-mentioned compiler; and the GUI is drawn by running the above-mentioned compiler that compiles the above parameters.

Further, obtaining the parameter for drawing the GUI by parsing the markup language file for drawing the GUI includes: classifying and parsing all the markup language files for drawing the GUI according to the interface level, and obtaining a binary analysis result; The above binary analysis result is cached in an analysis order; parameters for drawing the GUI are extracted from the above binary analysis result.

Further, after the foregoing binary parsing result is cached according to the parsing order, the method further includes: The result of the hexadecimal parsing is reordered according to a preset sorting rule, wherein after the above-mentioned binary parsing result is reordered according to the above-mentioned preset sorting rule, the binary parsing from the reordering is matched by matching the above-mentioned preset collation rules. The structured data used to draw the GUI described above is extracted from the results.

Further, by running the above compiler that compiles the above parameters, drawing the GUI includes: retrieving the parameters during the running of the compiler; and transmitting the parameters to the encapsulated graphics function interface; At least one of the preset GUI libraries calls a control structure that matches the above parameters; the GUI is drawn using the above-mentioned control structure invoked.

Further, by running the above compiler that compiles the above parameters, drawing the GUI includes: calling, by using a packaged system function interface, an operating environment required to draw the current GUI from a plurality of preset operating environments, where The above operating environment includes at least one of the following: an operating system and hardware resources.

According to another embodiment of the present invention, there is provided a drawing device for a GUI of a graphical user interface, comprising: an obtaining unit configured to pass a markup language for drawing the GUI before compiling a compiler for drawing the GUI The file is parsed to obtain parameters for drawing the GUI; the compiling unit is configured to compile the obtained parameters into the above compiling program; and the drawing unit is configured to draw the GUI by running the above compiling program that compiles the above parameters.

Further, the obtaining unit includes: a parsing module, configured to hierarchically parse all the markup language files for drawing the GUI according to the interface hierarchy to obtain a binary parsing result; and the caching module is configured to buffer the binary parsing result according to the parsing order; The extraction module is configured to extract parameters for drawing the GUI from the binary analysis result.

Further, the foregoing apparatus further includes: a sorting unit, configured to reorder the binary parsing result according to a preset sorting rule after buffering the binary parsing result according to the parsing order, wherein the extracting module is further configured to After the binary analysis results are reordered according to the above-mentioned preset sorting rules, the structured data for drawing the GUI is extracted from the reordered binary analysis results by matching the above-mentioned preset sorting rules.

Further, the drawing unit includes: a retrieval module configured to retrieve the parameter during the running of the compiler; the delivery module is configured to pass the parameter to the encapsulated graphic function interface; and the first calling module is configured to pass The graphics function interface invokes a control structure that matches the above parameters from at least one of a plurality of preset GUI libraries; the rendering module is configured to draw the GUI using the invoked control structure.

Further, the drawing unit includes: a second calling module, configured to invoke, by using a packaged system function interface, an operating environment required to draw the current GUI from a plurality of preset operating environments, where the operating environment includes At least one of the following: operating system and hardware resources.

In the embodiment of the present invention, a computer storage medium is further provided, and the computer storage medium may store an execution instruction for performing the implementation of the drawing method of the GUI in the foregoing embodiment.

According to the embodiment of the present invention, before compiling the compiler for drawing the GUI, the parameters for drawing the GUI are obtained by parsing the markup language file for drawing the GUI; and the obtained parameters are compiled into the compiler; Run the compiler that compiles the parameters, draw the GU, and solve the related technology that needs to be parsed for drawing during the compilation process. The parameter of the GUI causes a problem that the program execution efficiency is low, thereby achieving an effect of improving the execution efficiency of the program for drawing the GUI.

DRAWINGS

The drawings described herein are intended to provide a further understanding of the invention, and are intended to be a part of the invention. In the drawing:

1 is a flow chart of a method of drawing a graphical user interface GUI according to an embodiment of the present invention;

2 is a schematic diagram of a location of a GUI in an entire system according to an embodiment of the present invention;

3 is a flowchart of a script parsing layer parsing an XML document according to an embodiment of the present invention;

4 is a flow chart of a method of drawing a graphical user interface GUI in accordance with an alternative embodiment of the present invention;

FIG. 5 is a schematic diagram of a drawing device of a graphical user interface GUI according to an embodiment of the present invention.

detailed description

The invention will be described in detail below with reference to the drawings in conjunction with the embodiments. It should be noted that the embodiments in the present application and the features in the embodiments may be combined with each other without conflict.

It is to be understood that the terms "first", "second" and the like in the specification and claims of the present invention are used to distinguish similar objects, and are not necessarily used to describe a particular order or order.

In this embodiment, a method for drawing a GUI of a graphical user interface is provided. FIG. 1 is a flowchart of a method for drawing a GUI of a graphical user interface according to an embodiment of the present invention. As shown in FIG. 1 , the process includes the following steps:

Step S102, before compiling the compiler for drawing the GUI, obtaining parameters for drawing the GUI by parsing the markup language file for drawing the GUI;

Step S104, compiling the obtained parameters into the compiler;

In step S106, the GUI is drawn by running a compiler that compiles the parameters.

In order to achieve the independence of the GUI definition from the specific programming language and development platform, all GUI parameters and resources are defined by the markup language description method. Therefore, when drawing the GUI, the markup language file used to draw the GUI needs to be parsed and parsed into an assembly language or a binary language file.

In the embodiment of the present invention, the GUI system architecture for drawing a GUI mainly includes: a script parsing layer, a graphics layer, and a system encapsulation interface layer. In implementation, the script parsing layer may parse the markup language file used to draw the GUI before compiling the compiler for drawing the GUI to obtain parameters for drawing the GUI, and compile the parsed parameters into the program. In this way, during the execution of the program, the corresponding parameters can be extracted to draw the graphical interface.

Since the prior art solution is to parse the markup language file during program execution to obtain a GUI for drawing The parameter causes the execution of the program to be inefficient. The technical solution provided by the present invention is to parse the markup language file to obtain the parameters for drawing the GUI before the program is compiled, so that the parameters compiled in the program can be directly extracted during the drawing process, and the program is greatly improved. Execution efficiency.

Through the above steps, the problem that the parameters for drawing the GUI need to be parsed in the compiling process and the program execution efficiency is low is solved, and the effect of improving the execution efficiency of the program for drawing the GUI is achieved.

Optionally, by parsing the markup language file used to draw the GUI, obtaining parameters for drawing the GUI includes:

S2, hierarchically parsing all the markup language files used for drawing the GUI according to the interface hierarchy, and obtaining a binary analysis result;

S4, buffering the binary parsing result according to the parsing order;

S6, extracting parameters for drawing the GUI from the binary analysis result.

On the one hand, the parameters described by the markup language are parsed into parameters described by the binary language. At compile time, the machine-recognizable binary parameters can be directly compiled into the compiler; on the other hand, all markup language files are parsed according to the interface hierarchy. It can simplify the parsing logic, improve the parsing efficiency, and prevent the correct GUI from being drawn due to leak parsing or repeated parsing.

Optionally, after the binary parsing result is cached in the parsing order, the method further includes:

S8, the binary parsing result is reordered according to a preset sorting rule, wherein after the binary parsing result is reordered according to a preset sorting rule, the binary parsing result from the reordering is matched by matching a preset collating rule. Extract the structured data used to draw the GUI.

That is, before the compiler for drawing the GUI, the script parsing layer hierarchically parses all the markup language files describing the GUI according to the interface hierarchy, and the parsed data according to a preset sorting rule (such as a specific data arrangement protocol). ) After rearranging, get a binary file and cache it. In the process of loading the program for drawing the GUI, the structured data is extracted from the binary file by matching the aforementioned preset collation rules, and are respectively filled into some preset data structures. In this way, if a specific graphical interface needs to be drawn during the execution of the program, only the parameters corresponding to the corresponding GUI need to be retrieved from the data structure, thereby improving the loading speed of the parameters and the compilation efficiency of the program.

Optionally, by running a compiler that has compiled parameters, drawing the GUI includes:

S10, retrieving parameters during the running of the compiler;

S12, passing parameters to the encapsulated graphics function interface;

S14. Call, by using a graphics function interface, a control structure that matches a parameter from at least one of a plurality of preset GUI libraries;

S16, drawing the GUI using the called control structure.

That is, during the running of the compiler, various parameters compiled in the compiler can be retrieved, and the retrieved parameters are passed to a graphical function interface pre-packaged in the graphics layer, through which the graphical function interface can be derived from multiple At least one of the set GUI libraries calls a control structure that matches the parameters, and then directly draws the GUI using the invoked control structure.

Among them, the pre-packaged graphics function interface in the graphics layer is a package for various controls that make up the GUI. These controls can be divided into three categories, namely Control, GDI, and Image decoding. Control is the basic control that constitutes the GUI. Commonly used are Button, Label, Combobox, List, Textbox, Timer, etc.; GDI is a key technology to realize multi-window system, namely the cut domain technology, which can be embedded by cutting the domain. The complex platform is displayed on the platform to ensure that the drawing of one window does not affect the drawing of other windows. Image decoding is the decoding of different types of images. The supported image types are BMP, GIF, JEPG and PNG.

Since the technical solution provided by the related art does not encapsulate the graphic function interface, the GUI system architecture can only support a single type of GUI library; and the GUI system architecture designed by the present invention can be retrieved from a specific data structure during program execution. Go to the interface parameters and pass them to the packaged function interface to adapt to various GUI libraries, thus completing the corresponding GUI drawing tasks, improving the flexibility of the system, while the structure is clear, the resources are less, the performance is more efficient, and Easy to maintain.

In the embodiment of the present invention, the graphics layer in the GUI system architecture may be adapted to an existing GUI library, or may be a software interface provided by a chip manufacturer. A simple drawing operation can directly call the software interface provided by the chip manufacturer. The more complicated control drawing operation can be realized by the software interface provided by the packaged chip manufacturers.

S18, the operating environment required for drawing the current GUI is invoked from a plurality of preset operating environments through the encapsulated system function interface, where the operating environment includes at least one of the following: an operating system and hardware resources.

The system function interface is the encapsulation of the operating system and hardware platform at the system package interface layer. All system resources used in the GUI system architecture are obtained by calling the system function interface of the system package interface layer. The system function interface of the system package interface layer includes operating system related interfaces, such as memory management, process scheduling, timer management, semaphores, file systems, etc., as well as platform display, driver and other related interfaces, such as fill, blit, surface, and so on. In addition, the system package interface layer is located between the operating system and the application layer to isolate the different operating systems used by the lower layers.

In the implementation process, in the GUI drawing process, the system function interface of the system package interface layer is called to complete the call of the relevant interface such as the operating system or the platform driver, such as the application and release of the memory, the creation and release of the semaphore, and the creation and release of the thread. Wait. Through the system function interface of the system package interface layer, the GUI is adapted to a specific operating system and hardware platform, and finally the GUI is drawn and displayed.

By designing a lightweight embedded GUI system architecture, the invention can realize the purpose of adapting a plurality of graphics libraries, multiple operating systems and multiple hardware platforms in the GUI drawing process, and is simpler when the GUI is drawn. More flexible, clearer structure, smaller resources, faster response, and easier maintenance.

2 is a schematic diagram of a location of a GUI in an entire system according to an embodiment of the present invention. As shown in FIG. 2, a GUI system architecture serves as a graphics library system, and provides a service interface for a GUI of an upper layer APP (ie, a graphics function interface of a graphics layer package). ), Provide the corresponding interface for the system package interface layer package for the lower layer operating system and hardware platform.

3 is a flow chart of parsing an XML document by a script parsing layer according to an embodiment of the present invention. As shown in FIG. 3, all XML documents (such as XML1, XML2, ... XMLn) are subjected to XML parsing rules before the program is compiled. Parsing and caching, in order to facilitate compiling the parsing parameters into the compiler, the parsed data can be rearranged according to a preset collation to obtain a view.bin file. In the process of loading the GUI drawing program, the structured data is extracted from the view.bin file by matching the aforementioned preset collation rules, and filled into the preset data structure: string array, color array, image array , form linked list.

4 is a flowchart of a method for drawing a GUI of a graphical user interface according to an alternative embodiment of the present invention. As shown in FIG. 4, displaying a GUI in an APP requires relying on a GUI system architecture. The APP indexes the corresponding control parameters of the GUI to be drawn through the subscripts of the four data structures of string, color, image, and form, and then passes the control parameters to the GUI system architecture, implements the GUI drawing within the architecture, and advances through the APP. The set callback notifies the APP of the event information, and finally completes the drawing of the GUI.

Through the description of the above embodiments, those skilled in the art can clearly understand that the method according to the above embodiment can be implemented by means of software plus a necessary general hardware platform, and of course, by hardware, but in many cases, the former is A better implementation. Based on such understanding, the technical solution of the present invention, which is essential or contributes to the prior art, may be embodied in the form of a software product stored in a storage medium (such as ROM/RAM, disk, The optical disc includes a number of instructions for causing a terminal device (which may be a cell phone, a computer, a server, or a network device, etc.) to perform the methods described in various embodiments of the present invention.

In this embodiment, a drawing device of a GUI is also provided, which is used to implement the above-mentioned embodiments and preferred embodiments, and has not been described again. The term "module" as used below may implement a combination of software and/or hardware of a predetermined function. Although the apparatus described in the following embodiments is preferably implemented in software, hardware, or a combination of software and hardware, is also possible and contemplated.

FIG. 5 is a schematic diagram of a drawing device of a graphical user interface GUI according to an embodiment of the present invention. As shown in FIG. 5, the device includes: an obtaining unit 502, a compiling unit 504, and a drawing unit 506. The obtaining unit 502 is configured to obtain parameters for drawing the GUI by parsing the markup language file for drawing the GUI before compiling the compiler for drawing the GUI; the compiling unit 504 is configured to compile the acquired parameters to In the compiler, the drawing unit 506 is set to draw the GUI by running a compiler that compiles the parameters.

In order to achieve the independence of the GUI definition from the specific programming language and development platform, all GUI parameters and resources are defined by the markup language description method. Therefore, when drawing the GUI, the markup language file used to draw the GUI needs to be parsed and parsed into assembly language or binary language.

Since the prior art solution is to parse the markup language file during program execution to obtain parameters for drawing the GUI, the execution efficiency of the program is low. The technical solution provided by the present invention is to parse the markup language file to obtain the parameters for drawing the GUI before the program is compiled, so that the parameters compiled in the program can be directly extracted during the drawing process, and the program is greatly improved. Execution efficiency.

Optionally, the obtaining unit includes: a parsing module configured to hierarchically parse all the markup language files for drawing the GUI according to the interface hierarchy to obtain a binary parsing result; the caching module is configured to cache the binary parsing result according to the parsing order; and the extracting module , set to extract the parameters used to draw the GUI from the binary parsing results.

On the one hand, the parameters described by the markup language are parsed into parameters described by the binary language. At compile time, the machine-recognizable binary parameters can be directly compiled into the compiler; on the other hand, all markup language files are parsed according to the interface hierarchy. It can simplify the parsing logic, improve the parsing efficiency, and prevent the correct GUI from being drawn due to missing parsing or repeated parsing.

Optionally, the apparatus further includes: a sorting unit configured to: after buffering the binary parsing result according to the parsing order, reorder the binary parsing result according to a preset collation, wherein the extracting module is further configured to follow the binary parsing result according to After the pre-set collation is reordered, the structured data for drawing the GUI is extracted from the reordered binary parsing result by matching the pre-set collation.

Optionally, the drawing unit comprises: a retrieval module configured to retrieve parameters during the running of the compiler; a delivery module configured to pass the parameters to the encapsulated graphics function interface; the first calling module is set to pass the graphical function interface A control structure that matches the parameter is called from at least one of the plurality of preset GUI libraries; the drawing module is set to draw the GUI using the invoked control structure.

Among them, the pre-packaged graphics function interface in the graphics layer is a package for various controls that make up the GUI. These controls can be divided into three categories, namely Control, GDI, and Image decoding. Control is the basic control that constitutes the GUI. Commonly used are Button, Label, Combobox, List, Textbox, Timer, etc.; GDI is a key technology to realize multi-window system, namely the shear domain technology, which can display complex windows on the embedded platform through the cut domain. Ensure that the drawing of one window does not affect the drawing of other windows; Image decoding is the decoding of different types of pictures. The supported picture types are BMP, GIF, JEPG and PNG.

Optionally, the drawing unit includes: a second calling module, configured to invoke, by using the encapsulated system function interface, an operating environment required to draw the current GUI from a plurality of preset operating environments, where the operating environment includes at least the following One: operating system and hardware resources.

It should be noted that each of the above modules may be implemented by software or hardware. For the latter, the foregoing may be implemented by, but not limited to, the foregoing modules are all located in the same processor; or, the modules are located in multiple In the processor.

Embodiments of the present invention also provide a storage medium. Optionally, in the embodiment, the foregoing storage medium may be configured to store program code for performing the following steps:

S20. Before compiling the compiler for drawing the GUI, obtain a parameter for drawing the GUI by parsing the markup language file for drawing the GUI;

S22, compiling the obtained parameters into the compiler;

S24, drawing a GUI by running a compiler that compiles parameters.

Optionally, the storage medium is further configured to store program code for performing other steps in the preferred embodiments of the above-described embodiments, and details are not described herein again.

Optionally, in this embodiment, the foregoing storage medium may include, but not limited to, a USB flash drive, a Read-Only Memory (ROM), a Random Access Memory (RAM), a mobile hard disk, and a magnetic memory. A variety of media that can store program code, such as a disc or a disc.

Optionally, in this embodiment, the processor executes according to the stored program code in the storage medium:

S26. Before compiling the compiler for drawing the GUI, obtain a parameter for drawing the GUI by parsing the markup language file for drawing the GUI;

S28, compiling the obtained parameters into the compiler;

S30, drawing a GUI by running a compiler that compiles parameters.

Optionally, in this embodiment, the processor executes the program code of the other steps in the foregoing preferred embodiments in the foregoing embodiments according to the stored program code in the storage medium, and details are not described herein again.

For example, the specific examples in this embodiment may refer to the examples described in the foregoing embodiments and the optional embodiments, and details are not described herein again.

It will be apparent to those skilled in the art that the various modules or steps of the present invention described above can be implemented by a general-purpose computing device that can be centralized on a single computing device or distributed across a network of multiple computing devices. Alternatively, they may be implemented by program code executable by the computing device such that they may be stored in the storage device by the computing device and, in some cases, may be different from the order herein. The steps shown or described are performed, or they are separately fabricated into individual integrated circuit modules, or a plurality of modules or steps thereof are fabricated as a single integrated circuit module. Thus, the invention is not limited to any specific combination of hardware and software.

The above description is only the preferred embodiment of the present invention, and is not intended to limit the present invention, and various modifications and changes can be made to the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and scope of the present invention are intended to be included within the scope of the present invention.

Industrial applicability

The above technical solution provided by the embodiment of the present invention can be applied to the drawing process of the GUI, and before the compiler for drawing the GUI is compiled, the markup language file for drawing the GUI is parsed to obtain the GUI for drawing the GUI. The parameter is compiled into the compiler; the compiler is compiled by running the compiled parameter, and the GU is solved, which solves the problem that the related technology needs to parse the parameters used to draw the GUI during the compilation process, resulting in low program execution efficiency. Further, the effect of improving the execution efficiency of the program for drawing the GUI is achieved.

Claims

A method for drawing a GUI of a graphical user interface, comprising:

Obtaining parameters for drawing the GUI by parsing a markup language file for drawing the GUI before compiling a compiler for drawing the GUI;

Compiling the obtained parameters into the compiler;

The GUI is drawn by running the compiler that compiled the parameters.
The method of claim 1, wherein the obtaining parameters for drawing the GUI by parsing a markup language file for drawing the GUI comprises:

All the markup language files used to draw the GUI are hierarchically parsed according to the interface hierarchy, and a binary analysis result is obtained;

Caching the binary parsing result in parsing order;

Parameters for drawing the GUI are extracted from the binary analysis result.
The method of claim 2, wherein after the binary parsing result is cached in an analytical order, the method further comprises:

Reordering the binary parsing results according to a preset collation.

After the re-sorting the binary parsing result according to the preset collation rule, extracting the structure for drawing the GUI from the reordered binary parsing result by matching the preset collation rule Data.
The method of claim 1 wherein drawing the GUI by running the compiler that compiled the parameters comprises:

Retrieving the parameters during execution of the compiler;

Passing the parameters to the encapsulated graphics function interface;

Calling, by the graphics function interface, a control structure that matches the parameter from at least one of a plurality of preset GUI libraries;

The GUI is drawn using the called control structure.
The method of claim 1 wherein drawing the GUI by running the compiler that compiled the parameters comprises:

The operating environment required to draw the current GUI is invoked from a plurality of pre-set operating environments through a packaged system function interface, wherein the operating environment includes at least one of the following: an operating system and hardware resources.
A drawing device for a GUI of a graphical user interface, comprising:

An obtaining unit, configured to obtain a parameter for drawing the GUI by parsing a markup language file for drawing the GUI before compiling a compiler for drawing the GUI;

a compiling unit configured to compile the obtained parameters into the compiler;

A drawing unit is arranged to draw the GUI by running the compiler that compiled the parameters.
The apparatus of claim 6, wherein the obtaining unit comprises:

The parsing module is configured to perform hierarchical analysis on all the markup language files used to draw the GUI according to the interface hierarchy, to obtain a binary parsing result;

a cache module, configured to cache the binary parsing result in a parsing order;

An extraction module is configured to extract parameters for rendering the GUI from the binary analysis results.
The apparatus of claim 7 wherein said apparatus further comprises:

a sorting unit, configured to reorder the binary parsing results according to a preset collation after buffering the binary parsing results in a parsing order,

The extracting module is further configured to: after reordering the binary parsing result according to the preset sorting rule, extracting from the reordered binary parsing result by matching the preset collating rule The structured data of the GUI is drawn.
The apparatus of claim 6, wherein the drawing unit comprises:

Retrieving a module, configured to retrieve the parameter during execution of the compiler;

a delivery module configured to pass the parameter to the encapsulated graphics function interface;

a first calling module, configured to invoke, by the graphics function interface, a control structure that matches the parameter from at least one of a plurality of preset GUI libraries;

A drawing module is arranged to draw the GUI using the called control structure.
The apparatus of claim 6, wherein the drawing unit comprises:

a second calling module, configured to invoke, by using a packaged system function interface, a running environment required to draw the current GUI from a plurality of preset operating environments, wherein the operating environment includes at least one of the following: System and hardware resources.