Create a window Application

Create a window Application

Through the previous basic knowledge, we have learned how to use the basic functions of the ctypes library. In order to enhance this knowledge training and make use of the new knowledge, let's create an application that is a little more complex. This application is the foundation of all subsequent applications. Only by learning the basic principles of this program can we further learn WIN32 API program development. What's more, all the subsequent programs will be modified on this program, which is equivalent to the first step of your climb to the upper floor. In all engineering technologies, functions are gradually added from a small demo program to a powerful application. If you find that these API functions are unclear, you can refer to another book I wrote, "one-day training of Windows API", which contains a complete introduction and examples, however, these examples are written in C ++.

Next, let's start browsing the functions of the entire program. The first step is to import the ctypes library so that you can use its functions and import the ctypes library. wintypes, which has the corresponding WIN32 type, makes it easier to use, such as message structure MSG. The Code is as follows:

# Windows Applications

From ctypes import *

From ctypes. wintypes import *

Next, define the prototype of a Windows window callback function, because Windows specifies that each window requires a window message function to process all event messages in the window, in this way, the application you write has the opportunity to respond to events or operations in the window. This line of code is as follows:

WNDPROCTYPE = WINFUNCTYPE (c_int, HWND, c_uint, WPARAM, LPARAM)

Since WIN32 definition constants are all defined in the header file of the C language, it is impossible to directly use them in Python. Currently, there are only two methods: one is to use a conversion program to convert the header files provided by all sdks to the module files defined in Python; the other is to use those files by yourself, define those constants. In this example, the last method is used to define those constants when those constants are defined. In this example, the constants are defined as follows:

WS_EX_APPWINDOW = 0x40000

WS_OVERLAPPEDWINDOW = 0xcf0000

WS_CAPTION = 0xc00000

SW_SHOWNORMAL = 1

SW_SHOW = 5

CS_HREDRAW = 2

CS_VREDRAW = 1

CW_USEDEFAULT = 0x80000000

WM_DESTROY = 2

WHITE_BRUSH = 0

These constants mainly include the window format, style, and display mode, as well as a message definition and paint brush. Each newly created window must have a unique name in Windows, so that the corresponding window class can be found from the system memory during creation. All other Windows can use this window as the basic template, copy N identical ones. Each window has a topic name, also known as the window name. The two definition constants are as follows:

# Window class name

WclassName = u'shenzhencai'

Wname = u'hello world'

The first constant window class name, and the second constant is the title displayed in the window.

The window format and style are passed to the WIN32 API function by defining a structure. The struct of the window class is defined as follows:

# Define window class structure

Class WNDCLASSEX (Structure ):

_ Fields _ = [("cbSize", c_uint ),

("Style", c_uint ),

("LpfnWndProc", WNDPROCTYPE ),

("CbClsExtra", c_int ),

("CbWndExtra", c_int ),

("HInstance", HANDLE ),

("HIcon", HANDLE ),

("HCursor", HANDLE ),

("HBrush", HANDLE ),

("LpszMenuName", LPCWSTR ),

("LpszClassName", LPCWSTR ),

("HIconSm", HANDLE)]

The struct of this window class is the same as the struct described in C language. By defining this, you can describe the window type for the window. For the specific value of each item, see one-day Windows API practice. Next, check the window callback function, which defines the message received in the processing window. The main process is to exit the program when the window is closed (WM_DESTROY. Call the API function PostQuitMessage to send messages to the main program for loop. You need to end the application. Other messages are processed by default by calling the API function DefWindowProcW.

# Window message processing callback function

Def PyWndProc (hWnd, Msg, wParam, lParam ):

If Msg = WM_DESTROY:

Windll. user32.PostQuitMessage (0)

Else:

Return windll. user32.DefWindowProcW (hWnd, Msg, wParam, lParam)

Return 0

Next we will set the properties of the window class and register the window type so that we can create this window later. Here we mainly call the RegisterClassExW function for implementation. In addition, the preceding callback function WndProc, program instance handle hInst, and window class name wclassName are combined.

# Initializing the Main Window

Def initwinclass (hInst, WndProc ):

WndClass = WNDCLASSEX ()

WndClass. cbSize = sizeof (WNDCLASSEX)

WndClass. style = CS_HREDRAW | CS_VREDRAW

WndClass. lpfnWndProc = WndProc

WndClass. cbClsExtra = 0

WndClass. cbWndExtra = 0

WndClass. hInstance = hInst

WndClass. hIcon = 0

WndClass. hCursor = 0

WndClass. hBrush = windll. gdi32.GetStockObject (WHITE_BRUSH)

WndClass. lpszMenuName = 0

WndClass. lpszClassName = wclassName

WndClass. hIconSm = 0

Return windll. user32.RegisterClassExW (byref (wndClass ))

The callback function of the window has been defined, and the window type has been registered. Then, the window is created and displayed. The Code is as follows:

# Main Function entry

Def main ():

HInst = windll. kernel32.GetModuleHandleW (None)

WndProc = WNDPROCTYPE (PyWndProc)

If initwinclass (hInst, WndProc) <= 0:

Return False

HWnd = windll. user32.createappswexw (

0, wclassName, wname,

WS_OVERLAPPEDWINDOW | WS_CAPTION,

CW_USEDEFAULT, CW_USEDEFAULT,

800,600, 0, 0, hInst, 0)

If not hWnd:

Print ('failed' to create Windows ')

Exit (0)

Windll. user32.ShowWindow (hWnd, SW_SHOW)

Windll. user32.UpdateWindow (hWnd)

Msg = MSG ()

Lpmsg = pointer (msg)

Print ('entering message loop ')

While windll. user32.GetMessageW (lpmsg, 0, 0, 0 )! = 0:

Windll. user32.TranslateMessage (lpmsg)

Windll. user32.DispatchMessageW (lpmsg)

Print ('did .')

In this main function, integrate the content described above. If you have a better understanding of the previous introduction, it is easy to understand it here. If you still don't understand it, check the previous content and practice it more. The GetModuleHandleW function is used to obtain the instance handle of the current process. The WNDPROCTYPE function is used to convert the callback function. The initwinclass function is used to initialize the window type and register it. The createmediawexw function is used to create a window, the ShowWindow function is used to display the window, and the UpdateWindow function is used to refresh the display client area of the window. The pointer function is used to convert the message pointer, And the GetMessageW function is used to obtain the message of the window, the TranslateMessage function is used to convert messages. The DispatchMessageW function sends converted messages to the message queue. You can create a window, display window, and update window to display the window. After the message is cyclically processed, all events in the window are processed. Finally, there is another way to trigger the main function. Its implementation is as follows:

If _ name _ = "_ main __":

Print ("Win32 Application in python ")

Main ()

A Python feature is used here. When this file is first loaded for running, the name of the current file is set to _ main, in this way, the main function is called to run. When you run this example, the most exciting time is coming. The running result is as follows:

Programming is now the mainstream direction, and the friends who are learning programming are working hard and cheering.