JP2925734B2 - How to determine window size or move window - Google Patents

Description

Description: FIELD OF THE INVENTION The present invention relates to a method of sizing a window or moving a window.

[Problems to be Solved by the Related Art and the Invention] As a method of determining or moving a window,
Microsoft “Windows”, “Windows NT”, and IBM
A multi-window, multi-task program of "OS2" is well known. This type of program can be used to deploy applications running in other windows (developm
ent).

 It is an object of the present invention to overcome this disadvantage.

Means for Solving the Problems The object of the present invention is to provide a filter which intercepts a specific message in a method of determining a window size or moving a window in an application operating under a window management program such as "Windows". Between the core of the window manager and the various applications running under the window manager, processing these messages by specific applications, and taking no action on the part of the window manager. This is accomplished by sending a neutral message to the window manager that does not trigger and does not block the execution of this other application.

According to another feature, the processing performed by a particular application comprises processing each of the specific events that may occur, which potentially correspond to the event of moving a window or determining the size of a window. , Many parameters within this processing time, W_Top, W_Rig
ht, W_Bottom, W_Left, W_Caption, Frm_CurPos, h_Wnd
Consisting of calling specific functions that allow the initialization of Curr, those parameters are stored until a later event occurs, triggering the end of distance.

According to another feature, the stored parameters are the following: "h_WndCurr" = "h_WndCurrent", a variable indicating that the operation has started in any window, and remember that the icon has been loaded “B_LoadedIco
n "and, for icons," h_WndMenu "which is a variable indicating whether it is a menu execution or an icon move phase, the application is started and the specific cursor of this application is replaced Previously, the variable "h_OldCursor", which allows the identifier of the active cursor of the window manager to be stored, and the size, framing and minimum width between each "W_CXScree" which is the window coordinate variable
n "," w_CYScreen "," w_CXframe "," w_CYMinHeight ",
“W_CXMinWidth” and the current frame position variable “Frm_CurPos”
And the current mouse position variable "Mse_CurPos" and the direction variables "w_Left", "w_Top" and w_Rig used to calculate the coordinates of the new window and direction test.
ht ", w_Bottom", "w_Caption" and "Wnd_St" which are variables that define the initial position of the window
"artPos", a variable "Mse_StartPos" that defines the initial position of the cursor, and "b_Cursor and" b_LoadedIcon ", which are Boolean variables assumed to be false at the start.

According to another feature, there are two filters. The first "WM_GETMESSAGE" filter allows the following messages WM_NCLBUTTONDOWN, WM_MOUSEMOVE, WM_KEYDOWN, WM_SYSKEYDOWN, posted by hardware to be received, and a second "WH_CALLWNDPROC" The filter enables the following messages sent to the method WM_SYSCOMMAND, WM_ACTIVATEAPP, WM_NCACTIVATE, WM_ACTIVATWE, to be filtered and received.According to other features, intercepting messages is Trigger the processing of a specific program, and join the stored parameters and the following main processing functions that themselves call the utility function: ABMSInit for processing initialization, ABMSMove for window movement, and ABMSEnd for processing end.

According to another feature, the ABMSInit function is only executed to process the message "WM_NCLBUTTONDOWN" and the message "SC_SIZE" which depends on "WM_SYSCOMMAND".

According to another feature, the ABMSEnd function returns "WM_
LBUTTONUP "and the messages" VK_ESCAPE "and" VK_RETURN "depending on" WM_SYSKEYDOWN ".

According to another feature, the ABMSMove function returns "WM
"WM_MOUSEMO", a message that depends on "_SYSKEYDOWN"
Executed only to process VE, MK_LEFT, VK_UP, VK_RIGHT, and VK_DOWN "messages.

According to another feature, the ABMSInit function returns “SE
Adapt the mouse message with the "TCAPTURE" command, and then check if the window is a child of the parent window, ie, if a window has been written to this parent window to limit the movement of this child window And then initialize the initial coordinates of the window and the position of the cursor to the current coordinates, and furthermore, the characteristic parameters of the window (w_CX
frame, w_CXMinWidth, w_CYMinHeight).

According to other features, the method comprises the following steps. That is, the transition of the filter to the active mode, storing the identifier of the "h_Wnd" window into which the message is sent, and the kind of action resulting from this click zone, where the storage is achieved by the HitTest and ABMSInit functions. Remembering, adapting subsequent mouse messages to the window, drawing a ghost frame around the window first with the InvertBlock procedure, replacing the message with a message that is not processed by the window manager and “WM_ENTERID that does not trigger any action
Making the message neutral by substituting the LE "message.

According to other features, the method comprises the following steps. In other words, while removing ghosts by InvertBlock, ABMSC
Computing the final coordinates of the window with the omputNewPos procedure, drawing the window at the final position with the ABMSMove function, and resetting the storage parameters to zero with the ABMSEnd function.

According to a final feature, the method also comprises the following steps. In other words, it has a function of abandoning the ownership of the mouse message by the “Release Capture” command and shifting the filter to the active mode.

Embodiments Other features and advantages of the present invention will be more clearly understood from the following description with reference to the drawings.

The present invention provides a CPU (Central Processing Unit) or processor for processing a plurality of application programs and window management programs, a display monitor for displaying windows and various outputs of the application programs, and generating an interrupt. The present invention relates to an improvement of a multitasking, multiwindow program running on a computer device provided with possible keyboard resources and a mouse input device.

As is well known, this type of computer device has an external storage device, which stores an OS, a “Windows” management program and an application program (IBM OS / 2 is an OS and a window management device). When the computer is started, when a part of the OS and a "Windows" management program are executed in a storage device (internal memory) inside the CPU, a part thereof is loaded into the storage device.

A number of deficiencies are found in the prior art of FIG. 5, which illustrates the operation of a program that allows some applications to be executed with one or more windows per application. With this, Microsoft “Windows”, “Windows NT” environment or OS2
At (IBM), the core (1) of the window manager (eg, the "Windows" manager) is composed of various applications or tasks (T1, T2, T3) or (2
The messages (30, 31) are sent in the directions of 0, 21, and 23), respectively. The core of the window manager (1) is that the message (30, 31) is sent to the activated task, for example tasks (T1) and (T3) in the case of FIG. 5, and is addressed to each task. Allows these messages to be stacked in their respective queues (Q1, Q3). The window manager core (1) attaches the processor to the application, which then manages and processes the queued messages, and when the queue becomes empty, the task causes the processor to assign the processor to the window manager core. To (1) so that the processor can be attributed to other activated applications. Each application (T1, T3)
It has associated windows (F1, F3). Each window constitutes a visible or invisible object. Associated with each window is a method for configuring the use or reaction mode of the window for various messages relating to the application's window. The method is a program that processes each message and performs the resulting action. The program may choose to process some of these messages or allow some other messages to be processed by the window manager. In the latter case,
The application program requests that the message (33) be sent to the function (13) of the window management program core (1), and this function is called "default Windows Proc," (default window processor). The window management program core (1) can recognize these specific messages and further determine, for example, the window size,
Or, when moving a window, use standard processing (standa
rd processing). For this reason, an operator who wants to determine the window size executes a system "mouse" (mouse) which generates a large number of messages by interrupting hardware. These messages are stored, for example, in the queue (Q
Sent to 1) and stacked. When processing this queue, the program sends these messages to the window method and tries to find out where the mouse is located, either on the edge of the window, in the middle, or on the menu zone. Depending on the location, the method produces a number of different messages.

If the mouse is over the edge of the window, the resulting interrupt will generate the message "WM_LBUTTONDOWN". When this method recovers this message, it sends this message to function (13) “Def W
indow Proc "and handoff to the window manager. The window manager that detects this particular message finds the zone of the window from which the message was obtained and, in some cases," WM_SIZE "(window size To generate a large number of messages, such as "WM_MOVE" (corresponding to moving the window), and to process these messages quickly, so that subsequent messages from the mouse can be processed quickly. To wait.

The messages (30, 31) sent may be system messages sent directly to the application by the window manager core (1), or messages generated from hardware, such as mouse or keyboard messages, often generated after an interrupt. It can be any of How to message "Def Wnd Proc"
The processor will continue to execute this function as long as no other information about window sizing or movement has been reached in this function, sending it to the function and allowing function (13) to finish processing the message. Don't give up and wait for another message. This has the disadvantage of blocking the process that handles other tasks. This disadvantage is particularly problematic in real-time applications, such as real-time monitoring or alarm control. In this type of application, a window sizing or moving behavior using the keyboard is triggered, and the interrupted operator completes his window sizing or window moving action using the keyboard or mouse. You will block all other applications for the entire period of time you cannot.

Accordingly, it is an object of the present invention to eliminate this disadvantage and to operate the CPU of the computer device efficiently. A window management program core (1) in which the filter (4) is allocated to another part of the storage device as well as various applications (20, 21, 22) allocated to a part of the storage device such as a CPU internal memory. Indicating that this filter is hooked by the ABMS application (5) to the core of the window manager that ensures the processing of these messages when some messages pass through 1 is provided. Therefore, the messages (301, 321, 331) sent by the core of the window manager to the applications A, B, C (20, 21, 22) are input to the filter (4) and activated or deactivated. Depending on whether they are transmitted or processed by the ABMS. When the filter is active, some types of messages are transmitted in the form of messages to application A (at 304), application B (at 324), and application C (at 314). As shown in FIGS. 2 and 4, if one of the messages (301, 321, 311) corresponds to a particular event (50, 51, 52, 53), this message will be as shown below. Application ABMS (5)
Is intercepted and processed.

Therefore, the present invention is based on the message filter provided by the window management program. These filters can inform applications of the path of all messages corresponding to a particular type of event, and can modify or replace these messages before reaching their true destination. .

Therefore, the ABMS application (5) uses two of these specific filters. Since the window manager categorizes all messages into message families and the messages in this case belong to two of these families, the two filters need to cover all possible messages in this case. is there. The "WM_GETMESSAGE" filter (400, Appendix 1) allows for the receipt of hardware interrupts, ie messages normally posted in the application queue, notified by a mouse or keyboard. The other "WH_CALLWNPROC" (401, Appendix 1) allows to filter and receive all messages sent directly to the application's method. These filters are initialized when the ABMS application is installed, but their installation is indicated in FIG.
0) and is performed by the "SETWINDOWSHOOK" function. When the ABMS application terminates, the filter is deleted, and this deletion is indicated by reference numeral (41) in FIG.
SHOOK ”function. These filters installed are either passive, ie, do not affect the message, or are active, ie, cause special types of processing to occur from some particular event. If the filter is passive, the messages arriving at the filter (301, 321, 311) are transmitted to the application in a distributed fashion; if active, the filter sends the message to the ABMS for processing.

The options that ABMS considers can be broken down into a number of scenarios, categorized into three-dimensional tables (FIG. 3) that represent the actions, the means used, and the status of the scanned window. There are several issues that need to be resolved to realize an ABMS application, some of which are generic and described below, others are specific to the scenario. And is shown in the corresponding box in FIG.

A common problem relates to terminating an action if canceled by the ESC key. At this point, the initial situation recovery assumes that the ABMS application stores some pieces of information composed of the remaining variables. Another problem is the keyboard /
Mutual penetration of mouse scenarios. In fact, the frontier between the keyboard and mouse scenarios is not sealed, so that the restart process by one of these means can be continued by the other at any time.
ABMS takes this flexibility into account. Each message processed will evolve the general context of the application by changing the contents of the variables or manipulating the parameters defined in the data zone of the ABMS, and these variables will be used by other messages. Leave in a well-defined situation that can be taken over. These variables are represented as follows:

"H_WndCurr", which is a variable indicating that the operation was started in the window, and "h_WndMenu", which is a variable indicating whether the window is in the menu execution phase or the icon moving phase, in the case of the icon, and the application is started. The active cursor identifier of the window is stored before the call is made, and the variable between "h_OldCursor", which allows the particular cursor for this application to be replaced, and each of the variables that define size, framing, and minimum width "W_CXScree" which is a variable of window coordinates
n "," w_CYScreen "," w_CXframe "," w_CYMinHeigh
Used to calculate the coordinates of the "t", "w_CXMinWidth", the current position variable of the frame "Frm_CurPos", the current position variable of the mouse "Mse_CurPos", and the new window and direction tests. The direction variable “w_Le
ft "," w_Top "," w_Right "," w_Bottom "," w_Captio
n "and the definition variable of the initial window position (definition variab
le) “Wnd_StartPos” and the initial cursor position definition variable “Mse_StartPos”
And "b_Cursor" and "b_LoadedIcon", which are Boolean variables assigned to be false at the start.

In the case of window sizing performed solely by the mouse, not the icon, the operator must perform the following operations.

The operator places the mouse cursor on one of the edges of the window and keeps pressing the left button. Next, the mouse is moved, which has the effect of moving one of the edges representing the ghost of the window on the screen. If the user considers that the desired size has been reached, releasing the left button causes the window to be redrawn in the redefined frame. At the start of the operation, the filters installed by ABMS are initially passive. All mouse movement messages sent by the window manager core (1) are distributed. If the operator presses the left mouse button while the cursor is at the edge of the window, the window manager will generate a "WM_NCLBUTTONDOWN" message. The parameters of this message include the window identifier and a value defining the zone in which the event occurred. In this case, the ABMS action is as follows:

-Entering active mode, storing the identifier of the HWND window where the message and initial coordinates are targeted.

The type of action resulting from the click zone (left,
Right, top, bottom, and diagonal sizing) memory. This memory is stored in the ABMS Hit test portion of the program labeled (501) in Appendix 1 and Append Disk 7, and in the ABMS In test labeled (502, 403) in Appendix 3.
It is done by the it program.

-Assignment of subsequent mouse messages (via the SETCAPTURE command) to the window in question.

The first drawing of a ghost frame around the window by the ABMSInvertBlock, indicated by the reference (521) in Appendix 4. This cancels the previous ghost frame with each move and redraws the next one at the new location.

-Neutralization of messages by substituting "WM_ENTERIDLE" which is not processed by the window manager and causes no action.

When the ABMS program is started, the first function, indicated by reference number 40 in Appendix 1, either installs or removes the filter function. This filter function
Installed by "SETWINDOWSHOOK" function,
And the removal of the filter is performed by the "UNHOOKWINDOWSHOOK" function indicated by the reference numbers (40, 41) in FIG. Once this filter function has been activated, it will return “WM_SYSCOMMAND, WM_LBUTTONUP, WM_
All messages such as "SYSKEYDOWN, WM_NCLBUTTONDOWN, WM_MOUSEMOVE" are forwarded, processed by the ABMHook program, and "WM_ENT" of this application.
Neutralized by sending an "ERIDLE" message to the window manager. All these messages are first sent by the window manager after a keyboard or mouse interrupt.

Thereby, as shown in FIG.
When the "WM_NCLBUTTONDOWN" message is sent by the window manager, this message is sent to the ABMS
Intercepted by the Hook program. In the first phase (504), the program stores the identifier of the window for which this message is intended, and stores the variable "h_WndCur
Perform the test shown in the program (50) in Appendix 1 by line (500) to find out if this window is an icon in "r", and then in Appendix 7 by reference number (501) The part of the ABMSHit test program (501) in Appendix 1, which is shown in detail, stores this type of action resulting from the clicking zone and then appends it to Appendix 4.
Subprogram ABMSInit (502, 503), indicated in detail by reference numbers (502, 503)
Execute The program adapts subsequent mouse messages to the window with a "SETCAPTURE" message, and determines the window and the initial coordinates of the cursor position. "WM_NCL processing sequence (50)
"BUTTONDOWN" returns a "WM_ENTERIDLE" message at the end of the process.

The next message sent by the window manager can be a mouse movement indicated by the "WM_MOUSENOVE" message and handled by the instruction sequence (51) in Appendix 1, at the end of which the program will " WM_ENTERIDLE "
Handoff to the window manager by sending a message. Another command possibility is a mouse button release command, which is indicated by the window message "WM_LBUTTONUP" whose processing sequence (52) is shown in Appendix 1. This sequence starts the subprogram ABMSEnd, which hands off to the window manager core (1) to send "WM_ENTERIDLE" at the end.

"WM_MOU sent by the window manager
In the case of the "SEMOVE" message, the program checks if the object is iconic (iconic) by the reference number (510) in Appendix 1. If it is not, then the command (515) ) Checks if this direction variable has been initialized, if so, appendix 5
Starts the ABMSMove function (511) of, but if it has not been initialized,
The ction function (512) has the ABMSTestDirect function (513) of Appendix 8 as a parameter.
Is started to start the initialization of the direction variable according to the result of. If the object is iconic, the sequence starts loading the icon at the position indicated by the cursor and the ABMSLoadIcon function (5100) by instruction number (5111). This sequence then hands off to the window manager, sending a "WM_ENTERIDLE" message.

The ABMS indicates "WM_S" as indicated by reference number (53) in FIG.
When intercepting the "YSKEYDOWN" message, processing of this message starts a subprogram (53), which receives a "VK_RETURN" message or an escape message "VK_ESCAPE" and then the left movement key "VK_LEFT", When processing each case of the up-movement key "VK_UP", the right-movement key "VK_RIGHT" and the down-movement key "VK_DOWN", the process is started by processing when the return (carriage return) key is active. , For leftward movement (530),
A process corresponding to one of the sub-programs, such as for upward movement (531), rightward movement (532), and downward movement (533), is executed.

As described above, at the same time that the filter receives the message, this is processed, and after the corresponding processing, the ABMS program hands off to the window management program core (1), which can hand off to other applications, and Wait for a new message that requires processing that requires the intervention of an ABMS program. The filter remains active until the operator releases the left mouse button or presses "Enter" or "Esc". This action is called "WM_LBUTTONU
Generate a P, WM_SYSKEYDOWN, VK_ENTER, VK_ESCAPE "message, which causes the status of the ABMS filter to change from an active status to a passive status. The actions performed during this change are as follows: That is, the final window coordinates are calculated by the ABMSComputNewPos procedure indicated by the subprogram (5210) of Appendix 6, the ghost is deleted by the InvertBlock, the window at the final position is drawn, and the stored parameters are reset to zero. And relinquishing ownership of the mouse message with the “Release Capture” command, and transitioning the filter to passive mode.

As described above, due to the filters installed, the ABMS application sends various messages "WM_SYSCOMMAN
D, WM_NCLBUTTONDOWN, WM_MOUSEMOVE, WM_LBUTTONUP, W
M_SYSKEYDOWN, WM_KEYDOWN, WM_ACTIVATEAPP, WM_NCACT
IVATE, WM_ACTIVATE ". This application replaces these messages with a neutral message, such as" WM_ENTERIDLE ", for the window manager, and then calls the various calls that are made when it is detected that processing has begun. Continue processing these messages while calling the main processing function of.
These main processing functions are as follows. That is, the first “SC_MOVE” or “SC_SIZE” is “WM_SYSCOMMAND”
An ABMSInit function to initialize the process when received at the, which adapts the mouse message with the "SETCAPTURE" command, and then determines whether this window is a child window of the parent window, ie Checks if a window has been written to this parent window to limit the movement of this child window, then initializes the initial window coordinates and cursor position to the current coordinates, and further sets the window's characteristic parameters (w_CXFrame, w_CXMinWidth, w_CYMinHeight)
Consists of initializing Furthermore, ABMSEnd and ABMSMov
Including e-functions.

In addition to these three main functions, there are utility functions that are called at different points in the main function, and are useful for performing utility processing. These functions are as follows:

AB to help calculate and update window coordinates, taking into account global and remanent variables when mouse coordinates are given to it
MSComputNewPos function. AB of Appendix 5
The MSComputNewPos function (5210) calls the new positions W_Left, W_Caption, W_Top, W_Right, and W_Bottom.
It is calculated from parameters and allows mouse coordinates and window frames to be calculated from the lowest height and width coordinates of the window. This function also tests the limits of these calculations to ensure that child windows do not leave the parent window.

-ABMSDirection function in Appendix 6 (5
12) helps determine the shape of the cursor and initializes the direction variable as a function of the message received.
ABMSDirection function in Appendix 6 (51
2), for example, when the parameter returned by ABMSTestDirection is D_Top, the W_Top parameter is positioned at 1, and the cursor position is hooked on the upper edge of the window by the instruction number (5120). The sequence then tests the W_Left parameter to find out if W_Left has been initialized. If W_Left has been initialized, this sequence sends the message "D_TTOBDBLEARROW" to ask if the cursor display is tilted upward 40 °. W_Le
If ft has not been initialized, this sequence is W_Ri
Check if ght has been initialized. If W_Rig
If ht has been initialized, this sequence sends the message "D_BTOTDBLEARROW" to request that the cursor be displayed tilted upward left.
If the test for W_Right is negative, the message "D_VERTDBL
Executing "EARROW" displays a vertical cursor.

-ABMSHitTest function in Appendix 7 (50
1) during initialization, determines which zone was clicked, and helps to initialize direction variables in case of mouse movement. This function returns “WM_NCLBUTTONDOWN”
Called by ABMSInit when is received, and W_Top, W_Right, W_Bottom, W_Left, and W_Caption
Allows the variables to be initialized.

For this reason, as shown in Appendix 7,
ABMSHit when an HT_TopRight message is received, indicating that the top right corner was clicked with the mouse
The Test function sets the W_Top and W_Right variables to zero. This indicates that when a new message is received, initialization occurs in the upper right corner of the window, so that window movement or window size determination must be handled.

The ABMSInvertBlock function, indicated by reference number 5030 in Appendix 7, draws four adjacent rectangles commanded by the PatBlt function as a function of the hDC parameters and the dimensions of the window, indicated, for example, by P_RecFrm.left. Draw a rectangle by The DSTINVERT command allows this P
The atBlt function reverses the window ghost at the same time.

The ABMSLoadCursor function (5031) in Appendix 7 loads the cursor as a function of the parameters sent according to its position on the edge of the window.
Thus, if the parameters W_Left and W_Top are initialized to 1, the upper left edge of the window has been processed and the cursor initialized, as indicated by the arrow pointing to the lower right edge of the window, ie, 45 °. You will see.

-ABMSLoadIcon function in Appendix 8 (51
00) allows the cursor to be replaced by the static icon image generated by the window manager if the static icon has been moved. If the dynamic icon is moved further, the function allows this dynamic icon image to be replaced by the image constituted by the cursor.

-ABMST indicated by reference number (513) in Appendix 8
The estDirect function tests the information received by the application and sent by the window manager consisting of the X coordinate of the mouse position indicated by P_MSEPOS.X, so that parameters such as D_Left (5130) This function returns a D_Left message to the application if it decides to return it and compares this coordinate with the value of the left position of the window, and if the value of the mouse X coordinate is smaller than the abscissa of the left edge of the window To return. This function is used in conjunction with the ABMSDirection function.

-ABMSMove function in Appendix 5 (511)
Allows the window to be moved by inverting the ghost of the window by means of the ABMSInvertBlock function, indicated by the reference number (5030) in Appendices 5 and 7. The function is then the ABMSComputNewPos function (5210)
To calculate the new position of the window, and finally flip the window ghost to the calculated new position indicated by reference number (5112).

-ABMSEnd function in Appendix 4 (521)
Terminates the process by using the instruction (5211) to see if the window is iconified. If this is not the case, the end is a normal end (5212). Accordingly, the ABMSComputNewPos function (5210) is started. Otherwise, the cursor is restarted at its initial start position by the instruction (5213). This function also allows the sequence (5214) to determine whether the window being processed is a child window, and in this case invert the coordinates before moving. Thus this function is
If necessary, use the sequence (52
Reset the parameter to zero using 15) and by sequence (5216).

The application using the CalMsgHook filter is “WM
_SYSCOMMAND, WM_ACTIVATEAPP, WM_NCACTIVATE, WM_ACT
Enables messages that would have been sent directly to the application method containing the "IVATE" message to be filtered and received. "WM" shown at (54)
The processing of the "_SYSCOMMAND" message can be categorized as the processing of either the "SC_MOVE" or the "SC_SIZE" message, which positions the W_Caption parameter to 1 and is a message for determining the window size. “SC_SIZE” triggers the process indicated by (540). When the application receives a window size determination message, it requests the reference number (5401) for the mouse cursor position and further Requires the mouse cursor position. Then, at reference number (5402), the procedure starts the ABMSInit function, and the cursor position reference number (5403) is associated with the action performed. At the end of the process, the application sends the message number 541 to the window manager. Returns “WM_ENTERIDLE” and this message is “WM_ENTERIDLE”.
Replace with "SYSCOMMAND" message.

Thus, the GetMsgHook filter uses “WM_NCLBUTTON
DOWN, WM_MOUSEMOVE, WM_LBUTTONUP, WM_KEYDOWN, WM_S
YSKEYDOWN "message. This kind of" WM
When the "_NCLBUTTONDOWN" message reaches the ABMS application using the instruction number (504), it is checked whether this application is a menu run.
If it is not a menu run, whether it is working for the icon is found at reference number (500). If not working for the icon, the parameter is AMBSitT
It is confirmed whether or not initialization has been performed by the est function (501). If the parameters have not been initialized, start the ABMSInit function (502, 503) by storing it at the X and Y coordinate point comprising the message parameters. Then "WM_ENTERIDL
The E "message (505) is sent to the window manager for handing off to the window manager." WM_M "sent by the window manager
In the case of the "OUSEMOVE" message, the program checks whether the object is iconified at reference number (510) in Appendix 1. If the object is not iconified, the instruction (515) initializes the direction variable. Check if the program has been initialized, but in the case of initialization, the program will execute AMBSMove (511) in Appendix 5.
Start the function. If the direction variable has not been initialized, the ABMSDirection function (512) in Appendix 6 starts to initialize the direction variable resulting from the ABMSTestDirect function (513) in Appendix 8 as a parameter. If the object is iconified, the sequence consists of an instruction (5111) to start loading the icon at the position indicated by the cursor and the function ABMSLoad.
Use Icon (5100). The sequence then hands off to the window manager by sending the message "WM_ENTERIDLE".

If the message "WM_LBUTTONUP" is received from the application, it is seen at reference number (510) whether the operator has executed the menu. If not, the application checks whether the window coordinates correspond to the mouse coordinates, starts the ABMSEnd function (521), and then sends a "WM_ENTERIDLE" message to the window manager.

For messages sent after a key is depressed, the application is started at reference number (534) to handle the case of an abort key composed of escape (VK_ESCAPE) and return (VK_RETURN) keys. . Otherwise, if the application receives a VK_Left message, the application first checks whether it is in icon mode in the sequence of reference number 530 and returns the function ABMSLoa
Load the icon with dIcon (5100) and then check if the parameters W_Caption, W_Left, and W_Right have been initialized by instruction (5301). In addition, if they have been initialized, the application moves the icon or sequence (5302)
Depending on the actual size provided. If the icon mode is not working just at this point, the ABMSMove function is started and the mouse position is provided at the cursor position. Otherwise, ABMS is ABMSDirect
Start the ion function and then the message "WM_EN
TERIDLE "to the window manager.

The operation of the other parts of this program that handle the various events that may occur and invoke on the main processing function or on the utility function is inferred by the above description and the list of tables.

Appendices 1 through 8 detailing the various stages of the flowchart of FIG. 4 are shown below.

Before the appendix 1, a list of function blocks in the appendix and a list of roles of variables are shown.

Any modification within the skill of the artisan will be made without departing from the spirit and scope of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 shows an overall path diagram of the present invention.

 FIG. 2 shows the principle of operation of the filter of the present invention.

 FIG. 3 shows an executable scenario table.

FIG. 4 is a flowchart of the translation program when the filtering function is loaded once.

 FIG. 5 shows a conventional technique of the present invention.

Claims (12)

(57) [Claims] 1. A method for sizing or moving one of a plurality of application windows in a window operating system, comprising: providing at least one filter between the window operating system and the application window; Intercepting at least one message passing between a window operating system and the application window; processing the at least one intercepted message by a unique application; and neutralizing a message to the window operating system. And the neutral message then requests that the window operating system take further action. Without allowing the window operating system to perform tasks in other application windows. 2. The method of claim 1, wherein processing the at least one intercepted message further comprises: processing each of a plurality of mouse and keyboard events corresponding to window movement or window sizing events; 2. The method of claim 1, further comprising: initializing parameters of the application window. 3. The plurality of application window parameters include: a variable indicating whether an operation has been started in the application window; a variable indicating whether an icon has been loaded; A variable indicating whether it is a movement phase, a variable indicating an identifier of an active cursor, a plurality of variables indicating coordinates of the application window at the time of sizing and framing, and a variable indicating a current position of the application window; A variable indicating the current mouse position; a plurality of variables recording direction information relating to the mouse and keyboard events of the variable; a variable recording the initial position of the application window; and a variable recording the initial position of the cursor. The method according to claim 2, comprising: Law. 4. The unique application includes two filters, one for receiving multiple hardware interrupts from a mouse or keyboard, and another for intercepting and receiving messages sent directly to the application window. The method of claim 1. 5. The step of intercepting the at least one message further comprises: triggering processing of a message-specific application; accessing parameters of the application window; and performing processing initialization; 5. The method of claim 4, comprising: performing the application window movement and using a plurality of functions to complete processing. 6. The method of claim 5, wherein the processing initialization function processes only mouse events associated with a mouse button being depressed and keyboard events requesting sizing of an application window. 7. The method of claim 5, wherein the processing termination function processes only mouse events associated with the mouse button being released and keyboard events associated with "Escape" and "Return" key inputs. . 8. The method of claim 5, wherein the window movement function processes only mouse events related to mouse movement and keyboard events related to directional key input. 9. The processing initialization function further comprises the steps of: adapting mouse events; and determining whether the window is written as a child window inside the parent window to limit window movement. 7. The method of claim 6, comprising the steps of: initializing the initial coordinates of the window and the position of the cursor to be the current coordinates, and initializing the characteristic parameters of the window. 10. A method for sizing or moving one of a plurality of application windows in a window operating system, comprising: providing at least one filter between the window operating system and the application window; Intercepting at least one message passing between an operating system and the application window; and processing the at least one intercepted message, wherein the processing of the message comprises: Activating the at least one filter; storing parameters of the application window to which the at least one intercepted message is sent. Storing the type of action required by the at least one intercepted message; exclusively adapting subsequent mouse events for processing by the native application; Drawing a ghost frame around the application window and returning a neutral message to the window operating system, wherein the neutral message does not require any action, A method that allows the operating system to proceed with processing tasks in other application windows. 11. The method of claim 11, further comprising: calculating a final position of the application window; erasing a ghost frame; drawing a window at the final position; and setting the storage parameter to zero. 11. The method of claim 10, comprising: resetting. 12. The method of claim 11, further comprising: allowing the mouse message to be read by another function; and deactivating the filter.