CN107357576B - Method and system for multi-window parallel drawing of Windows application program - Google Patents
Method and system for multi-window parallel drawing of Windows application program Download PDFInfo
- Publication number
- CN107357576B CN107357576B CN201710519798.4A CN201710519798A CN107357576B CN 107357576 B CN107357576 B CN 107357576B CN 201710519798 A CN201710519798 A CN 201710519798A CN 107357576 B CN107357576 B CN 107357576B
- Authority
- CN
- China
- Prior art keywords
- window
- sub
- static memory
- main window
- windows
- 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
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/01—Input arrangements or combined input and output arrangements for interaction between user and computer
- G06F3/048—Interaction techniques based on graphical user interfaces [GUI]
- G06F3/0487—Interaction techniques based on graphical user interfaces [GUI] using specific features provided by the input device, e.g. functions controlled by the rotation of a mouse with dual sensing arrangements, or of the nature of the input device, e.g. tap gestures based on pressure sensed by a digitiser
- G06F3/0488—Interaction techniques based on graphical user interfaces [GUI] using specific features provided by the input device, e.g. functions controlled by the rotation of a mouse with dual sensing arrangements, or of the nature of the input device, e.g. tap gestures based on pressure sensed by a digitiser using a touch-screen or digitiser, e.g. input of commands through traced gestures
- G06F3/04886—Interaction techniques based on graphical user interfaces [GUI] using specific features provided by the input device, e.g. functions controlled by the rotation of a mouse with dual sensing arrangements, or of the nature of the input device, e.g. tap gestures based on pressure sensed by a digitiser using a touch-screen or digitiser, e.g. input of commands through traced gestures by partitioning the display area of the touch-screen or the surface of the digitising tablet into independently controllable areas, e.g. virtual keyboards or menus
-
- 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
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Human Computer Interaction (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- User Interface Of Digital Computer (AREA)
- Digital Computer Display Output (AREA)
Abstract
The invention discloses a method for multi-window parallel drawing of a Windows application program, which comprises the following steps: creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows; calling an OnPaint () function to execute the interface drawing operation of the main window, and storing the drawing result of the main window into the global static memory space; judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window; if so, enumerating and drawing all the child windows contained in the main window in the drawing operation of the OnPaint () function, and outputting and displaying the drawing result; if not, the drawing result is directly output and displayed. The invention also provides a system for multi-window parallel drawing of the Windows application program. By implementing the technical scheme provided by the invention, the multi-window drawing efficiency of the Windows application program can be improved.
Description
Technical Field
The invention relates to the technical field of embedded systems, in particular to a method and a system for multi-window parallel drawing of a Windows application program.
Background
With the development of computer technology, computer devices are widely used in various aspects of life and work. In these computer devices, a Windows operating system from microsoft corporation is usually installed, and a user can run various application programs including web browsing, document writing, and the like through the Windows operating system. Windows is an operating system for a graphical user interface that displays all data, including text, as images on a screen.
MFC (Microsoft Foundation classes) Class library (Class L ibreries) contains a large number of Windows handle encapsulation classes and a large number of encapsulation classes of built-in controls and components of Windows, which encapsulates APIs (application programming interfaces) of Windows in the form of C + + classes, and contains an application framework, which masks the characteristics of the display device and provides a uniform drawing interface for programmers to reduce the workload of application developers.
The current general method of using MFC to delineate interfaces is: a window inherited from CDialog is created as an interface, and the window is taken as a main window (also called a parent window) to create a plurality of child windows. After the main window is established, the OnInitDialog () function of the main window is called, and the MFC correspondingly processes the WM _ PAINT message according to the established window sequence to respectively call the OnPaint () function and draw the backgrounds of all the windows.
However, the difference between the CPU, the memory, and the like of the embedded system and the PC is large, and after the MFC method is used to enter an interface including a plurality of windows (for example, on a keyboard interface for input), because each window needs to call an OnPaint () function (a series of creating resources, drawing, releasing resources, and the like), a user visually sees that the windows on the interface are created and drawn one by one in sequence, the display effect is very unsmooth, the machine performance and the drawing effect are poor, and the user experience effect is very poor.
Disclosure of Invention
The technical problem to be solved by the invention is to provide a technical scheme for multi-window parallel drawing of a Windows application program, realize control of multi-window simultaneous drawing, avoid the phenomenon of unsmooth interface caused by sequential drawing of a parent window and each child window when entering a main window interface every time, improve the multi-window drawing effect of the Windows application program in an embedded system, and improve user experience.
To solve the above technical problem, in one aspect, an embodiment of the present invention provides a method for multi-window parallel drawing of a Windows application, including:
creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows;
creating a class library of a Windows application program, calling an OnPaint () function from the class library to execute interface drawing operation of a main window, and storing a drawing result of the main window into the global static memory space;
judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window;
if so, enumerating and describing all sub-windows contained in the main window in the description operation of the OnPaint () function, storing the description result in the global static memory space, and outputting and displaying the description result; if not, directly outputting and displaying the drawing result stored in the global static memory space.
In an implementable manner, the enumerating and drawing all the child windows included in the main window in the drawing operation of the OnPaint () function, and storing the drawing result in the global static memory space includes:
calling OnPaint () function at the main window to enumerate all the sub-windows contained in the current main window, acquiring handles of all the sub-windows, and storing a sub-window delineation queue to be delineated in the global static memory space;
sending a self-defined drawing message to each sub-window;
each sub-window respectively responds to the corresponding self-defined drawing message, executes the parallel sub-window drawing operation and puts the drawing result into the global static memory space;
and emptying the child window drawing queue in the global static memory space, and updating the zone bit of the main window.
Further, each of the sub-windows respectively responds to the corresponding custom rendering message, and performs a parallel sub-window rendering operation, specifically including:
registering a custom drawing message;
each sub-window respectively responds to the drawing operation of the OnPaint () function according to the received self-defined drawing message, and judges whether the current sub-window executes the drawing operation of the OnPaint () function for the first time according to the zone bit of the sub-window;
if so, resetting the flag bit of the current sub-window and outputting and displaying the drawing result stored in the global static memory space; if not, executing the drawing of the current child window, storing the drawing result in the global static memory space, and outputting and displaying.
On the other hand, the embodiment of the invention also provides a system for multi-window parallel drawing of a Windows application program, which comprises the following steps:
the window configuration module is used for creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows;
the system comprises a main window drawing module, a class library execution module and a main window drawing module, wherein the main window drawing module is used for creating a class library of a Windows application program, calling an OnPaint () function from the class library to execute interface drawing operation of a main window, and storing a drawing result of the main window to the global static memory space;
the main window state detection module is used for judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window;
a child window drawing module, configured to enumerate and draw all child windows included in the main window in the drawing operation of the onpoint () function when the main window executes the drawing operation of the onpoint () function for the first time, and store the drawing result in the global static memory space;
and the drawing result output module is used for outputting and displaying the drawing results stored in the global static memory space.
In one implementation, the sub-window rendering module includes:
an enumeration module, configured to invoke an OnPaint () function in a main window to enumerate all sub-windows included in a current main window, obtain handles of each sub-window, and store a sub-window rendering queue to be rendered in the global static memory space;
the message sending module is used for sending a self-defined drawing message to each sub-window;
the child window response module is used for responding the corresponding self-defined drawing messages respectively by each child window, executing parallel child window drawing operation and placing the drawing result into the global static memory space;
and the updating module is used for emptying the child window drawing queue in the global static memory space and updating the zone bit of the main window.
Further, the sub-window response module includes:
the registration module is used for registering the user-defined drawing message;
the message response module is used for responding to the drawing operation of the OnPaint () function respectively by each sub-window according to the received self-defined drawing message;
the child window state detection module is used for judging whether the current child window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the child window;
the operation returning module is used for resetting the zone bit of the current sub-window when the current sub-window executes the drawing operation of the OnPaint () function for the first time, and driving the drawing result output module to output and display the drawing result stored in the global static memory space;
and the child window drawing execution module is used for executing the drawing of the current child window when the current child window does not execute the drawing operation of the OnPaint () function for the first time, storing the drawing result in the global static memory space, and driving the drawing result output module to output and display the drawing result.
The technical scheme of the Windows application program multi-window parallel drawing provided by the embodiment of the invention copies all the contents to be drawn of the child Windows into the same global static memory space, configures a global static memory bitmap, and finally draws all the contents in an OnPaint () function of a main window (namely a father window); when the OnPaint () function of the main window is executed for the second time, the contents of all the sub-windows do not need to be drawn together; and directly returning to the top layer when the required OnPaint () function is described by the child window for the first time, and drawing the content of the child window when the OnPaint () function of the child window is called for the second time. Since the global static memory DC (Device Context) and the global static memory bitmap are used at each place needing to be described in the whole life cycle of the operation of the embedded system, the creation and destruction operations of the memory DC and the memory bitmap are not required to be frequently executed. Therefore, all contents can be described only by once execution, the unsmooth description effect when a plurality of Windows are sequentially described is avoided, the drawing efficiency of Windows application program multiple Windows in the embedded system is improved, and the user experience is improved.
Drawings
FIG. 1 is a flowchart illustrating an embodiment of a method for multi-window parallel drawing of a Windows application program according to the present invention.
FIG. 2 is a schematic structural diagram of an embodiment of a system for multi-window parallel drawing of a Windows application according to the present invention.
Detailed Description
The technical solution in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. While exemplary embodiments of the invention are shown in the drawings, it should be understood that the invention can be embodied in various forms and should not be limited to the embodiments set forth herein. These embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art.
Fig. 1 is a schematic flowchart of an embodiment of a method for multi-window parallel drawing of a Windows application according to the present invention.
Specifically, the method for drawing Windows application program in parallel with multiple Windows provided in this embodiment mainly includes the following steps:
step S1: and creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows. Specifically, a global static memory device environment m _ dcTemporary (global static memory space) and a global static memory bitmap m _ bitmap are created for multi-window parallel description; the global static memory space and the memory bitmap are used at each place needing to be described in the whole life cycle of the system operation, and the creation and destruction operations of the memory space and the memory bitmap are not required to be frequently executed. In this embodiment, specifically, the global static memory space and the global static memory bitmap are created at the entry of the OnPaint () function of each window.
Step S2: creating a class library of a Windows application program, calling an OnPaint () function from the class library to execute the interface drawing operation of the main window, and storing the drawing result of the main window into the global static memory space. The class library is packaged with the API and the application program framework of Windows.
Step S3: judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window; if yes, go to step S4; if not, step S5 is executed directly. In specific implementation, the flag bit is set to True when each interface (main window) is created, and is set to False after the main window executes one drawing operation of the OnPaint () function; and the next time the interface (main window) is re-entered, the interface (main window) is re-created, and the flag bit of the main window is set to True.
Step S4: enumerating and describing all child windows contained in the main window in the description operation of the OnPaint () function, storing the description result in the global static memory space, and executing step S5;
step S5: and outputting and displaying the drawing result stored in the global static memory space.
When the OnPaint () operation of the interface of the main window (parent window) is executed for the first time, the method copies the contents to be described of all the child windows into the same global static memory space, and finally describes all the contents in the OnPaint () method of the main window. And when the OnPaint () operation of the main window is executed for the second time, the contents of the sub-windows are not drawn together.
In an implementation manner, the step S4 can be implemented by the following steps, including:
step S41: calling OnPaint () function in the main window to enumerate all the sub-windows contained in the current main window, acquiring handles of all the sub-windows, and storing a sub-window description queue to be described in the global static memory space. In the present embodiment, handles are used to identify different objects in an application and different instances in a same class.
Step S42: a custom rendering message is sent to each sub-window.
Step S43: and each sub-window respectively responds to the corresponding self-defined drawing message, executes the parallel sub-window drawing operation and puts the drawing result into the global static memory space.
Step S44: and emptying the child window drawing queue in the global static memory space, and updating the zone bit of the main window.
Finally, the step S5 is executed to output and display the drawing result stored in the global static memory space.
Specifically, in step S43, when each of the sub-windows responds to the corresponding custom rendering message and performs the parallel sub-window rendering operation, the method includes:
step S431: registering a custom drawing message;
step S432: each child window respectively responds to the drawing operation of the OnPaint () function according to the received self-defined drawing message;
step S433: judging whether the current sub-window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the sub-window; if yes, go to step S434; if not, go to step S435;
step S434: resetting the flag bit of the current sub-window, and executing the step S5 (outputting and displaying the drawing result stored in the global static memory space);
step S435: and drawing the current child window, and executing the step S5 (outputting and displaying the drawing result stored in the global static memory space).
When the OnPaint () method of the child window is called for the first time, the OnPaint () method returns directly, the drawing control right is handed to the main window, and the contents are drawn uniformly by the main window; when the child window recalls the OnPaint () operation for the second time, the child window is responsible for drawing the content of the current child window. When each child window receives the OnPaint operation, each child window executes corresponding drawing operation in parallel.
In the embodiment of the invention, when the OnPaint () operation of the main window is executed by entering the interface for the first time, all the contents of all the windows (including the main window and the sub-windows) are put into the same global memory space by lifting all the sub-windows, and the drawing is finished by the OnPaint () operation of a parent window; when the OnPaint () operation of each child window is entered for the first time, the operation returns immediately without any operation; when OnPaint () operation of a main window and a child window is not entered for the first time, each window only needs to finish the description content of the main window (different from the first entry); therefore, all contents can be described only by once execution, excessive resource occupation caused by sequential description of a plurality of windows is avoided, and the effect is not smooth.
Since the global static memory DC (Device Context) and the global static memory bitmap are used in each place to be described in the whole life cycle of the operation of the embedded system provided by the embodiment, the creation and destruction operations of the memory DC and the memory bitmap are not required to be frequently performed. Therefore, all contents can be described only by once execution, the unsmooth description effect when a plurality of Windows are sequentially described is avoided, the drawing efficiency of Windows application program multiple Windows in the embedded system is improved, and the user experience is improved.
Corresponding to the method for Windows application program multi-window parallel drawing provided by the embodiment, the invention also provides a system for Windows application program multi-window parallel drawing.
Fig. 2 is a schematic structural diagram of a system for multi-window parallel drawing of a Windows application according to an embodiment of the present invention.
Specifically, the system for Windows application multi-window parallel drawing comprises:
a window configuration module 100, configured to create a main window and multiple sub-windows belonging to the main window, and create a global static memory space and a global static memory bitmap for the main window and the sub-windows;
a main window description module 200, configured to create a class library of a Windows application, call an OnPaint () function from the class library to perform an interface description operation of a main window, and store a description result of the main window in the global static memory space;
a main window state detection module 300, configured to determine whether the main window executes the rendering operation of the OnPaint () function for the first time according to the flag bit of the main window;
a child window rendering module 400, configured to enumerate and render all child windows included in the main window in the rendering operation of the onpoint () function when the main window executes the rendering operation of the onpoint () function for the first time, and store the rendering result in the global static memory space;
and a rendering result output module 500, configured to output and display the rendering result stored in the global static memory space.
In one implementation, the sub-window rendering module 400 includes:
an enumeration module 401, configured to invoke an OnPaint () function in a main window to enumerate all sub-windows included in a current main window, obtain handles of each sub-window, and store a to-be-depicted sub-window depiction queue in the global static memory space;
a message sending module 402, configured to send a custom drawing message to each sub-window;
a sub-window response module 403, configured to respond to the corresponding custom rendering message respectively for each sub-window, execute parallel sub-window rendering operations, and place the rendering result in the global static memory space;
an updating module 404, configured to empty the child window rendering queue in the global static memory space, and update a flag bit of the main window;
preferably, the sub-window response module 403 includes:
a registration module 4031 for registering a custom drawing message;
a message response module 4032, which is used for each child window to respectively respond to the drawing operation of the OnPaint () function according to the received self-defined drawing message;
a child window state detection module 4033, configured to determine whether the current child window executes the rendering operation of the OnPaint () function for the first time according to the flag bit of the child window;
an operation returning module 4034, configured to reset a flag bit of the current child window when the current child window executes the rendering operation of the OnPaint () function for the first time, and drive the rendering result output module 500 to output and display the rendering result stored in the global static memory space;
a child window drawing execution module 4035, configured to execute, when the current child window does not execute the drawing operation of the OnPaint () function for the first time, drawing of the current child window, store the drawing result in the global static memory space, and drive the drawing result output module 500 to output and display the drawing result.
The system for Windows application multi-window parallel drawing provided in this embodiment corresponds to the same working principle as the method for Windows application multi-window parallel drawing provided in the embodiment of fig. 1, and is not described herein again.
It should be noted that the system for multi-window parallel drawing may also have additional resources and devices. For example, storage (removable and/or non-removable) media included in the system include, but are not limited to, magnetic or optical disks or tape. Storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as embedded system program instructions, data files, data structures, program modules or other data. Storage media includes, but is not limited to, RAM, ROM, EEPR0M, flash memory or other memory technology, CD-ROM, Digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the system. Any such storage media may be part of a system. The information may be embedded system readable instructions, data structures, modules of a program, or other data.
Applications executing on the computing device are implemented using embedded system-executable instructions, such as program modules, and/or interpreted instructions that are processed by the computing device. Generally, program modules include routines, programs, objects, components, data structures, etc. that, when processed by a processing unit, instruct the processing unit to perform particular tasks or implement particular abstract data types. Program modules may be located in both local and remote memory storage media including memory storage devices.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.
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. Furthermore, the present application may take the form of a program product embodied on one or more available storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.
While the foregoing is directed to the preferred embodiment of the present invention, it will be understood by those skilled in the art that various changes and modifications may be made without departing from the spirit and scope of the invention.
Claims (6)
1. A method for multi-window parallel drawing of Windows application programs is characterized by comprising the following steps:
creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows;
creating a class library of a Windows application program, calling an OnPaint () function from the class library to execute interface drawing operation of a main window, and storing a drawing result of the main window into the global static memory space;
judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window;
if so, enumerating and describing all sub-windows contained in the main window in the description operation of the OnPaint () function, storing the description result in the global static memory space, and outputting and displaying the description result; if not, directly outputting and displaying the drawing result stored in the global static memory space.
2. The method for multi-window parallel drawing of Windows application according to claim 1, wherein enumerating and drawing all sub-Windows included in a main window in the drawing operation of the OnPaint () function, and storing the drawing result in the global static memory space, comprises:
calling OnPaint () function at the main window to enumerate all the sub-windows contained in the current main window, acquiring handles of all the sub-windows, and storing a sub-window delineation queue to be delineated in the global static memory space;
sending a self-defined drawing message to each sub-window;
each sub-window respectively responds to the corresponding self-defined drawing message, executes the parallel sub-window drawing operation and puts the drawing result into the global static memory space;
and emptying the child window drawing queue in the global static memory space, and updating the zone bit of the main window.
3. The method for Windows application multi-window parallel drawing as claimed in claim 2, wherein each of the sub-Windows respectively responds to the corresponding custom drawing message to perform the parallel sub-window drawing operation, specifically comprising:
registering a custom drawing message;
each sub-window respectively responds to the drawing operation of the OnPaint () function according to the received self-defined drawing message, and judges whether the current sub-window executes the drawing operation of the OnPaint () function for the first time according to the zone bit of the sub-window;
if so, resetting the flag bit of the current sub-window and outputting and displaying the drawing result stored in the global static memory space; if not, executing the drawing of the current child window, storing the drawing result in the global static memory space, and outputting and displaying.
4. A system for multi-window parallel drawing of Windows application programs, comprising:
the window configuration module is used for creating a main window and a plurality of sub-windows belonging to the main window, and creating a global static memory space and a global static memory bitmap for the main window and the sub-windows;
the system comprises a main window drawing module, a class library execution module and a main window drawing module, wherein the main window drawing module is used for creating a class library of a Windows application program, calling an OnPaint () function from the class library to execute interface drawing operation of a main window, and storing a drawing result of the main window to the global static memory space;
the main window state detection module is used for judging whether the main window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the main window;
a child window drawing module, configured to enumerate and draw all child windows included in the main window in the drawing operation of the onpoint () function when the main window executes the drawing operation of the onpoint () function for the first time, and store the drawing result in the global static memory space;
and the drawing result output module is used for outputting and displaying the drawing result stored in the global static memory space when the main window does not execute the drawing operation of the OnPaint () function for the first time.
5. The system for Windows application multi-window parallel drawing according to claim 4, wherein the sub-window rendering module comprises:
an enumeration module, configured to invoke an OnPaint () function in a main window to enumerate all sub-windows included in a current main window, obtain handles of each sub-window, and store a sub-window rendering queue to be rendered in the global static memory space;
the message sending module is used for sending a self-defined drawing message to each sub-window;
the child window response module is used for responding the corresponding self-defined drawing messages respectively by each child window, executing parallel child window drawing operation and placing the drawing result into the global static memory space;
and the updating module is used for emptying the child window drawing queue in the global static memory space and updating the zone bit of the main window.
6. The system for Windows application multi-window parallel drawing as in claim 5, wherein the sub-window response module comprises:
the registration module is used for registering the user-defined drawing message;
the message response module is used for responding to the drawing operation of the OnPaint () function respectively by each sub-window according to the received self-defined drawing message;
the child window state detection module is used for judging whether the current child window executes the drawing operation of the OnPaint () function for the first time or not according to the zone bit of the child window;
the operation returning module is used for resetting the zone bit of the current sub-window when the current sub-window executes the drawing operation of the OnPaint () function for the first time, and driving the drawing result output module to output and display the drawing result stored in the global static memory space;
and the child window drawing execution module is used for executing the drawing of the current child window when the current child window does not execute the drawing operation of the OnPaint () function for the first time, storing the drawing result in the global static memory space, and driving the drawing result output module to output and display the drawing result.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710519798.4A CN107357576B (en) | 2017-06-30 | 2017-06-30 | Method and system for multi-window parallel drawing of Windows application program |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710519798.4A CN107357576B (en) | 2017-06-30 | 2017-06-30 | Method and system for multi-window parallel drawing of Windows application program |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107357576A CN107357576A (en) | 2017-11-17 |
| CN107357576B true CN107357576B (en) | 2020-07-28 |
Family
ID=60274082
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710519798.4A Active CN107357576B (en) | 2017-06-30 | 2017-06-30 | Method and system for multi-window parallel drawing of Windows application program |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107357576B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108536492B (en) * | 2018-04-08 | 2021-09-07 | 武汉斗鱼网络科技有限公司 | Method, device, equipment and storage medium for acquiring attribute information of live broadcast room |
| CN114265659A (en) * | 2021-12-27 | 2022-04-01 | 飞天诚信科技股份有限公司 | Method and device for displaying popup frame by iOS system |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101499006A (en) * | 2004-05-06 | 2009-08-05 | 柳濑隆敏 | Window display system and window display method |
| CN102272824A (en) * | 2009-01-06 | 2011-12-07 | 三菱电机株式会社 | Drawing layer control device |
| CN103383662A (en) * | 2013-04-27 | 2013-11-06 | 惠州市德赛西威汽车电子有限公司 | Method for solving RAM (Random Access Memory) fragments generation during drawing of Windows GDI (Graphics Device Interface) |
| CN104331297A (en) * | 2014-11-28 | 2015-02-04 | 广东威创视讯科技股份有限公司 | Drawing method and drawing device for render engine |
| CN104391699A (en) * | 2014-11-10 | 2015-03-04 | 北京元心科技有限公司 | Dynamic processing method and system for multiple window layers |
| CN105302569A (en) * | 2015-11-18 | 2016-02-03 | 网易（杭州）网络有限公司 | Method and device used for generating special-shaped window |
| CN105404512A (en) * | 2015-11-25 | 2016-03-16 | 飞天诚信科技股份有限公司 | Application window interface changing method and apparatus |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR101891794B1 (en) * | 2011-11-28 | 2018-08-27 | 삼성전자주식회사 | Supplementary Window Displaying Method And Portable Device supporting the same |
-
2017
- 2017-06-30 CN CN201710519798.4A patent/CN107357576B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101499006A (en) * | 2004-05-06 | 2009-08-05 | 柳濑隆敏 | Window display system and window display method |
| CN102272824A (en) * | 2009-01-06 | 2011-12-07 | 三菱电机株式会社 | Drawing layer control device |
| CN103383662A (en) * | 2013-04-27 | 2013-11-06 | 惠州市德赛西威汽车电子有限公司 | Method for solving RAM (Random Access Memory) fragments generation during drawing of Windows GDI (Graphics Device Interface) |
| CN104391699A (en) * | 2014-11-10 | 2015-03-04 | 北京元心科技有限公司 | Dynamic processing method and system for multiple window layers |
| CN104331297A (en) * | 2014-11-28 | 2015-02-04 | 广东威创视讯科技股份有限公司 | Drawing method and drawing device for render engine |
| CN105302569A (en) * | 2015-11-18 | 2016-02-03 | 网易（杭州）网络有限公司 | Method and device used for generating special-shaped window |
| CN105404512A (en) * | 2015-11-25 | 2016-03-16 | 飞天诚信科技股份有限公司 | Application window interface changing method and apparatus |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107357576A (en) | 2017-11-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7900154B2 (en) | Method and apparatus for selecting a layout for a user interface to display on an electronic device | |
| US6983357B2 (en) | Hardware accelerator for an object-oriented programming language | |
| US6330659B1 (en) | Hardware accelerator for an object-oriented programming language | |
| US6246403B1 (en) | Method and apparatus for generating a graphical user interface | |
| RU2483350C2 (en) | Layout manager | |
| US6633313B1 (en) | Event routing mechanism in a computer system | |
| US20060031818A1 (en) | Hardware accelerator for an object-oriented programming language | |
| Robinson et al. | Swing | |
| US20060117267A1 (en) | System and method for property-based focus navigation in a user interface | |
| US20090055757A1 (en) | Solution for automatically generating software user interface code for multiple run-time environments from a single description document | |
| JP2004501409A (en) | System and method for managing a scalable list of items for display | |
| US7603624B2 (en) | System and method for styling content in a graphical user interface control | |
| CN107357576B (en) | Method and system for multi-window parallel drawing of Windows application program | |
| CN103902258A (en) | Method and device for displaying self-defined menu in webpage | |
| US11520473B2 (en) | Switch control for animations | |
| US6560770B1 (en) | Extending the attributes of an application generated using a fourth generation programming tool | |
| US8212818B2 (en) | Windowless shape drawing | |
| CN109582308B (en) | Interactive map component dynamic embedding method and system based on XEmbed | |
| CN113688343B (en) | Page authority control method, device, equipment and readable storage medium | |
| CN104267954A (en) | Generation method and device for units included in user interface | |
| Lee et al. | Event-Driven Programming | |
| US20120072891A1 (en) | Computer Language Syntax for Automatic Callback Function Generation | |
| US10768911B2 (en) | Managing software components for software application development | |
| US8832711B1 (en) | User interface for event-driven state thread architecture | |
| US20230385134A1 (en) | System and method to enhance launching of application at a user equipment |
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 |