VS Creates Win32 Application Program (Implementing Window Creation) (II)

The procedure framework is as follows:

I. VS Demonstration Process

Open VS - File - New - Project - Windows Desktop Application

Generate code: (Most functions have been explained in the previous article)

// The first window. cpp: Defines the entry point of the application.
#include "stdafx.h"
#include "First Window. h"
#define MAX_LOADSTRING 100

  // Global variables:
HINSTANCE hInst;                                // Current instance
WCHAR szTitle[MAX_LOADSTRING];                  // Title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // Main window class name

// Forward declaration of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);    // Register window class
BOOL                InitInstance(HINSTANCE, int);            //Window initialization (create, display, update)
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);     // Message Processing
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);       // Pop-up dialog box

Main function WinMain

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);   //The goal is to avoid the compiler's warning about unreferenced parameters
    UNREFERENCED_PARAMETER(lpCmdLine);       //The goal is to avoid the compiler's warning about unreferenced parameters

    // TODO: Place the code here.

    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_MY, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // Execute application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MY));

    MSG msg;

    // The main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}

Register window class MyRegisterClass()

//  Function: MyRegisterClass()
//
//  Target: Register window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MY));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_MY);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

Initialization window InitInstance()

//   Function: InitInstance(HINSTANCE, int)
//   Target: Save the instance handle and create the main window
//   Notes:
//        In this function, we save the instance handle in the global variable and
//        Create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handles in global variables
//Note: The window class name SZ Windows Class here is the same as the window class registered earlier.
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

Message Processing WndProc

//  Functions: WndProc(HWND, UINT, WPARAM, LPARAM)
//  Target: Processing messages from the main window.
//  WM_COMMAND - Processing Application Menu
//  WM_PAINT - Draw Main Window
//  WM_DESTROY - Send an exit message and return

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Analysis menu selection:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Add any drawing code using hdc here.
             LPCWSTR text1 = TEXT("VS Win32 window creation");
			TextOut(hdc, 0, 0, text1, lstrlen(text1));
			MessageBox(NULL, TEXT("VS Win32 window creation"), TEXT("hoade"), MB_OK);
			![](https://img-blog.csdnimg.cn/20190731143942499.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDIxMTgw,size_16,color_FFFFFF,t_70)
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

About Message Processing of Box

// About box message handler.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

Third, the effect of code operation:

IV. Supplementary:

4.1 Use of UNREFERENCED_PARAMETER

4.2 LoadStringW()

Function prototype
The resource of the project file (in this case, string, found by ID number) is loaded into the instance's cache (loaded by pointer, and the size of the buffer is specified)

LoadStringW( _In_opt_ HINSTANCE hInstance,    // Instance handle    
             _In_ UINT uID,                   // Existing resource ID (name)    
             _Out_writes_to_(cchBufferMax, return + 1) LPWSTR lpBuffer,//Cache pointer for storing resources  
             _In_ int cchBufferMax);          // The size of the storage resource buffer 

4.3 Call in LoadAccelerators()

LoadAccelerators function: Call in the acceleration key table. This function calls into the specified acceleration key table.
Acceleration keys are also called keyboard shortcuts.

Function prototype:

HACCEL LoadAccelerators(HINSTANCE hlnstance，
                         LPCTSTR lpTableName)；

Parameters:

Return value:

4.4 MSG message structure

Architectural prototype:

MSG msg;
	{
       	HWND        hwnd;     //Window handle
    	UINT        message;  //Message id, message passed in
	    WPARAM      wParam;   //Message Auxiliary Parameters
	    LPARAM      lParam;   //Message Auxiliary Parameters
    	DWORD       time;     //Message delivery time
	    POINT       pt;       //Location of the mouse when the message is generated
	}

4.5 Role of MAKEINTRESOURCEW