• Windows application - an application with Windows graphical user interface (GUI)

• Note all standard features of a Windows application:
  • The main window: resizing, minimizing, maximizing, the icon, system menu in the icon, menu in the window
  • About - the modal dialog box: it must be closed to allow the user to do something with the main window, it is not resizable

• <project_name>.h - almost empty by default, use it as the main header file in your application
• Resource.h - contains identifiers of resources, it is better to use the Resource View window in Visual Studio rather than modify it manually
• stdafx.h - the file generated by Visual Studio for all C++ projects. Include directives for header files used by all .cpp files should be placed here. Definitions of very important constants that specify the target Windows version for the application and #include <windows.h> directive can be found here.
  • If there are any problems with 'precompiled headers' after adding a new .cpp file to the project, just add the #include "stdafx.h" directive at the beginning of the new file
• Resource files - all files used in the application's resources: two icons and the .rc file by default
• <project_name>.cpp - the main file with source code of the application
• stdafx.cpp - the file used for precompiled headers

• Accelerator - the table with keyboard shortcuts used in the application. To add a new accelerator just click below the list of used shortcuts, set the identifier of the menu item for which the keyboard shortcut is to create, right click on the new item, choose the 'Next Key Typed' option and just press the desired combination of keys
• Dialog - dialog boxes, unlike normal windows, can be designed visually. The Toolbox window (View / Toolbox) can be used to add new so-called controls and the Properties window (View / Properties Window) can be used to alter some of their default settings (unfortunately, unlike Windows Forms, in Win32 applications some of obvious visual features can be changed only from the source code)
• Icon - when editing an icon, be sure to modify all types of the icon (see the menu option: Image / Current Icon Image Types) - which type of the icon is used depends on the version of the system and on the context (e.g. the 16x16 type will be used for the window's icon, the 32x32 type in the Alt-Tab window, etc.)
• Menu - use very functional editor built in Visual Studio and remember about the Properties window
• String Table - if there is a need to display a text to the user, this text should be loaded from the string table (using the LoadString function) to allow to easily develop multilingual versions of the application and to set the user interface's language by the system, according to the system's settings

• _tWinMain function - the entry point of the application, returning from this function means terminating the application (the while (GetMessage(...)) loop ends when the PostQuitMessage function is called)
• MyRegisterClass function - a helpful function which registers the class of the main window of the application (by calling the RegisterClassEx function)
• InitInstance function - to create and show the main window
• WndProc function - the function responding to all messages sent to the main window
• About function - the message handling function for the About dialog box

• To find desired information use the Index tab (menu: Help / Index) and type the name. Among all available options choose something with 'Platform SDK', 'Windows Management' or 'GDI' (e.g. try to find help about the GetLastError function). If something about a method of a class is displayed, you are lost, because there are no object oriented programming in Win32 API.

case WM_SIZE:
{
    // get the size of the client area
    int clientWidth = LOWORD(lParam);
    int clientHeight = HIWORD(lParam);

    // get the size of the window
    RECT rc;
    GetWindowRect(hWnd, &rc);

    // modify the caption of the window
    TCHAR s[256];
    _stprintf_s(s, 256, _T("Window's size: %d x %d   Client area's size: %d x %d"), 
        rc.right - rc.left, rc.bottom - rc.top, clientWidth, clientHeight);
    SetWindowText(hWnd, s);
}
break;

• Both the width and height of the window's client area are passed in one parameter of the message (LPARAM), the LOWORD and HIWORD macros can be used to retrieve single values
• The rectangle passed to the GetWindowRect function will be filled with values of the current position and size of the window
• TCHAR, _stprintf_s, and _T can be used to write the source code independent on the setting of using Unicode in the application
  • To use Unicode and wide character explicitly, wchar_t, swprintf_s, and L"" can be used:

    wchar_t s[256];
    swprintf_s(s, 256, L"Window's size: %d x %d   Client area's size: %d x %d", 
        rc.right - rc.left, rc.bottom - rc.top, clientWidth, clientHeight);
    SetWindowText(hWnd, s);

  • Unicode is supported at the system level since Windows 2000 and it is really good idea to use it (it is much easier to create multilingual applications)!

case WM_GETMINMAXINFO:
{
    MINMAXINFO *minMaxInfo = (MINMAXINFO*)lParam;
    minMaxInfo->ptMaxSize.x = minMaxInfo->ptMaxTrackSize.x = 500;
    minMaxInfo->ptMaxSize.y = minMaxInfo->ptMaxTrackSize.y = 200;
}
break;

case WM_SIZING:
{
    RECT *rc = (RECT*)lParam;
    if (wParam == WMSZ_BOTTOM || wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_BOTTOMRIGHT ||
        wParam == WMSZ_TOP || wParam == WMSZ_TOPLEFT || wParam == WMSZ_TOPRIGHT) 
    {
        rc->right = rc->left + rc->bottom - rc->top;
    } else {
        rc->bottom = rc->top + rc->right - rc->left;
    }
}
break; 

case WM_CREATE:
    SetTimer(hWnd, 7, 250, NULL);
    break;

• Explanation: the WM_CREATE message is sent to the window procedure only once (when the CreateWindow or CreateWindowEx function is called); it is the first message when the handle of the window (HWND) is available and it is great place to do some initialization of the window (the window is already created but not visible)

case WM_TIMER:
{
    RECT rc;

    // get the center of the work area of the system
    SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0);
    int centerX = (rc.left + rc.right + 1) / 2;
    int centerY = (rc.top + rc.bottom + 1) / 2;

    // get current size of the window
    GetWindowRect(hWnd, &rc);
    int currentSize = max(rc.right - rc.left, rc.bottom - rc.top);

    // modify size of the window
    currentSize += stepSize;
    if (currentSize >= maxSize) {
        stepSize = -abs(stepSize);
    } else if (currentSize <= minSize) {
        stepSize = abs(stepSize);
    }
    MoveWindow(hWnd, centerX - currentSize / 2, centerY - currentSize / 2,
        currentSize, currentSize, TRUE);
}
break;

• The above code needs some declarations:

  const int minSize = 200;
  const int maxSize = 400;
  static int stepSize = 10;

  (be sure to understand the importance of the static keyword)
• Explanations:
  • The SystemParametersInfo function is very useful when there is a need to get or set values of some system parameters
  • There are many functions for changing window's size and/or position, MoveWindow is the simplest one

void GetTextInfoForMouseMsg(WPARAM wParam, LPARAM lParam, TCHAR *msgName,
							TCHAR *buf, int bufSize)
{
	short x = (short)LOWORD(lParam);
	short y = (short)HIWORD(lParam);
	_stprintf_s(buf, bufSize, _T("%s x: %d, y: %d, vk:"), msgName, x, y);
	if ((wParam & MK_LBUTTON) != 0) {
		_tcscat_s(buf, bufSize, _T(" LEFT"));
	}
	if ((wParam & MK_MBUTTON) != 0) {
		_tcscat_s(buf, bufSize, _T(" MIDDLE"));
	}
	if ((wParam & MK_RBUTTON) != 0) {
		_tcscat_s(buf, bufSize, _T(" RIGHT"));
	}
}

case WM_LBUTTONDOWN:
	GetTextInfoForMouseMsg(wParam, lParam, _T("LBUTTONDOWN"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_LBUTTONUP:
	GetTextInfoForMouseMsg(wParam, lParam, _T("LBUTTONUP"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_RBUTTONDOWN:
	GetTextInfoForMouseMsg(wParam, lParam, _T("RBUTTONDOWN"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_RBUTTONUP:
	GetTextInfoForMouseMsg(wParam, lParam, _T("RBUTTONUP"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_LBUTTONDBLCLK:
	GetTextInfoForMouseMsg(wParam, lParam, _T("LBUTTONDBLCLK"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_MBUTTONDBLCLK:
	GetTextInfoForMouseMsg(wParam, lParam, _T("MBUTTONDBLCLK"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;
case WM_RBUTTONDBLCLK:
	GetTextInfoForMouseMsg(wParam, lParam, _T("RBUTTONDBLCLK"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;

const int bufSize = 256;
TCHAR buf[bufSize];

• WM_L... messages are for the left mouse button, WM_M... for middle, and WM_R... for the right one
• Notifications about pressing (WM_xBUTTONDOWN) and releasing (WM_xBUTTONUP) are sent
• The WM_xBUTTONDBLCLK message is sent when the user use the double click. To get the notification, the CS_DBLCLKS style must be applied to WNDCLASSEX::style in calling the RegisterClassEx function:

  wcex.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;

  When the CS_DBLCLKS style is applied, the following sequence of messages is sent when the user use the double click:
      WM_xBUTTONDOWN  WM_xBUTTONUP  WM_xBUTTONDBLCLK  WM_xBUTTONUP
  When there is no this style, the WM_xBUTTONDBLCLK message is not sent:
      WM_xBUTTONDOWN  WM_xBUTTONUP  WM_xBUTTONDOWN  WM_xBUTTONUP

void GetTextInfoForMouseMsg(HWND hWnd, WPARAM wParam, LPARAM lParam, TCHAR *msgName,
							TCHAR *buf, int bufSize)
{
	short x = (short)LOWORD(lParam);
	short y = (short)HIWORD(lParam);
	POINT pt = {x, y};
	ClientToScreen(hWnd, &pt);
	_stprintf_s(buf, bufSize, _T("%s x: %d, y: %d, (sx: %d, sy: %d) vk:"), 
		msgName, x, y, pt.x, pt.y);

case WM_LBUTTONDOWN:
	GetTextInfoForMouseMsg(hWnd, wParam, lParam, _T("LBUTTONDOWN"), buf, bufSize);
	SetWindowText(hWnd, buf);
	SetCapture(hWnd);
	break;
case WM_LBUTTONUP:
	ReleaseCapture();
	GetTextInfoForMouseMsg(hWnd, wParam, lParam, _T("LBUTTONUP"), buf, bufSize);
	SetWindowText(hWnd, buf);
	break;

case WM_CREATE:
    cursor = LoadCursor(NULL, IDC_HAND);
    break;
case WM_SETCURSOR:
    SetCursor(cursor);
    return TRUE;

static HCURSOR cursor = NULL;

• To change the mouse cursor, the WM_SETCURSOR message and the SetCursor function can be used
• The SetCursor function needs an HCURSOR parameter which represents a cursor. It can be loaded from resources or from the system using the LoadCursor function
• The above code changes the cursor for all areas of the window
• It is possible to use simpler code: SetCursor(LoadCursor(NULL, IDC_HAND)); but it would be less efficient
• The NULL value as the first parameter of the LoadCursor method means, that the cursor must be loaded from the system (not from resources of the application)
• To use a cursor from applications resources:
  1. Add the cursor to resources (using the Resource View window in Visual Studio)
  2. Pass the hInst variable as the first parameter for the LoadCursor function, e.g.
     LoadCursor(hInst, IDC_MYCURSOR)

case WM_NCHITTEST:
    return HTCAPTION;

void GetTextInfoForKeyMsg(WPARAM wParam, TCHAR *msgName, TCHAR *buf, int bufSize)
{
    static int counter = 0;
    counter++;
    _stprintf_s(buf, bufSize, _T("%s key: %d (counter: %d)"), msgName, wParam, counter);
}

case WM_KEYDOWN:
    GetTextInfoForKeyMsg(wParam, _T("KEYDOWN"), buf, bufSize);
    SetWindowText(hWnd, buf);
    break;
case WM_KEYUP:
    GetTextInfoForKeyMsg(wParam, _T("KEYUP"), buf, bufSize);
    SetWindowText(hWnd, buf);
    break;

case WM_CHAR:
    _stprintf_s(buf, bufSize, _T("WM_CHAR: %c"), (TCHAR)wParam);
    SetWindowText(hWnd, buf);
    break;

• The simplest way to draw a text:

  case WM_PAINT:
  {
  	hdc = BeginPaint(hWnd, &ps);
  	TCHAR s[] = _T("Hello world!");
  	TextOut(hdc, 0, 0, s, (int)_tcslen(s));
  	EndPaint(hWnd, &ps);
  }
  break;

• More options are available when the DrawText function is used:

  case WM_PAINT:
  {
      hdc = BeginPaint(hWnd, &ps);
      TCHAR s[] = _T("Hello world!");
      RECT rc;
      GetClientRect(hWnd, &rc);
      DrawText(hdc, s, (int)_tcslen(s), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
      EndPaint(hWnd, &ps);
  }
  break;

• Explanations:
  • The GetClientRect function gets the rectangle of the client area of the window (the left and top members are always set to 0)
  • Using the last parameter of the DrawText function, the alignment of the text can be changed

• The HPEN is a handle to a pen and represents a pen in drawing using GDI

  case WM_PAINT:
  {
      hdc = BeginPaint(hWnd, &ps);
      HPEN pen = CreatePen(PS_SOLID, 2, RGB(255, 0, 0));
      HPEN oldPen = (HPEN)SelectObject(hdc, pen);
  
      MoveToEx(hdc, 0, 0, NULL);
      LineTo(hdc, 100, 100);
  
      SelectObject(hdc, oldPen);
      DeleteObject(pen);
      EndPaint(hWnd, &ps);
  }
  break;

• Explanations:
  • GDI always uses current objects (one pen, one brush, one font, etc.) to draw, the object can be selected as current on the device context (HDC) using the SelectObject function.
  • The colour contains 3 values: for the red, green, and blue. The RGB macro can be used to set specific colour, its parameters are integer values from the range [0..255])
  • VERY IMPORTANT: All created GDI objects must be destroyed. The pen created using the CreatePen function must be destroyed using the DeleteObject.
  • VERY IMPORTANT: Objects selected as current on the device context cannot be destroyed (so always remember the old object and restore it before calling the DeleteObject function)

• Brushes are similar to pens, they are used when something must be filled, e.g. a rectangle:

  case WM_PAINT:
  {
      hdc = BeginPaint(hWnd, &ps);
      HPEN pen = CreatePen(PS_DOT, 1, RGB(255, 0, 0));
      HPEN oldPen = (HPEN)SelectObject(hdc, pen);
      HBRUSH brush = CreateSolidBrush(RGB(0, 128, 0));
      HBRUSH oldBrush = (HBRUSH)SelectObject(hdc, brush);
  
      Rectangle(hdc, 20, 20, 120, 120);
  
      SelectObject(hdc, oldPen);
      DeleteObject(pen);
      SelectObject(hdc, oldBrush);
      DeleteObject(brush);
      EndPaint(hWnd, &ps);
  }
  break;

case WM_PAINT:
{
    hdc = BeginPaint(hWnd, &ps);
    TCHAR s[] = _T("Hello world!");

    HFONT font = CreateFont(
        -MulDiv(24, GetDeviceCaps(hdc, LOGPIXELSY), 72),  // Height
        0,                                                // Width
        0,                                                // Escapement
        0,                                                // Orientation
        FW_BOLD,                                          // Weight
        false,                                            // Italic
        FALSE,                                            // Underline
        0,                                                // StrikeOut
        EASTEUROPE_CHARSET,                               // CharSet  
        OUT_DEFAULT_PRECIS,                               // OutPrecision
        CLIP_DEFAULT_PRECIS,                              // ClipPrecision
        DEFAULT_QUALITY,                                  // Quality
        DEFAULT_PITCH | FF_SWISS,                         // PitchAndFamily
        _T("Verdana"));                                   // Facename
    HFONT oldFont = (HFONT)SelectObject(hdc, font);

    RECT rc;
    GetClientRect(hWnd, &rc);
    DrawText(hdc, s, (int)_tcslen(s), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

    SelectObject(hdc, oldFont);
    DeleteObject(font);
    EndPaint(hWnd, &ps);
}
break;

• Add a bitmap to resources (right click on the project in the Solution Explorer window in Visual Studio, Add / Resource, and choose Bitmap in the dialog box)
• Draw something on the bitmap (there is a simple image editor built in Visual Studio)
• Save the bitmap (note, that a .bmp file is created)
• Check an identifier of the bitmap in the Resource View window (it should be IDB_BITMAP1 by default)
• Copy the following code for the WM_PAINT message

  case WM_PAINT:
  {
      hdc = BeginPaint(hWnd, &ps);
      TCHAR s[] = _T("Hello world!");
  
      HBITMAP bitmap = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_BITMAP1));
      HDC memDC = CreateCompatibleDC(hdc);
      HBITMAP oldBitmap = (HBITMAP)SelectObject(memDC, bitmap);
  
      BitBlt(hdc, 0, 0, 48, 48, memDC, 0, 0, SRCCOPY);
      StretchBlt(hdc, 200, 100, -200, 100, memDC, 0, 0, 48, 48, SRCCOPY);
  
      SelectObject(memDC, oldBitmap);
      DeleteObject(bitmap);
      DeleteDC(memDC);
      EndPaint(hWnd, &ps);
  }
  break;

• Explanations:
  • There is no function for drawing a bitmap on a device context, another device context must be used
  • To create a memory device context use the CreateCompatibleDC function. Each created device context must be destroyed using the DeleteDC function
  • The BitBlt function copies a bitmap from one device context to another one, the StretchBlt function allows to resize the bitmap

case WM_LBUTTONDOWN:
{
    hdc = GetDC(hWnd);
    HBRUSH brush = CreateSolidBrush(RGB(128, 128, 0));
    HBRUSH oldBrush = (HBRUSH)SelectObject(hdc, brush);
 
    short x = (short)LOWORD(lParam);
    short y = (short)HIWORD(lParam);
    const int rad = 5;
    Ellipse(hdc, x - rad, y - rad, x + rad, y + rad);
 
    SelectObject(hdc, oldBrush);
    DeleteObject(brush);
    ReleaseDC(hWnd, hdc);
}
break;

• The BeginPaint and EndPaint functions can be used only in response for the WM_PAINT message, in all other cases the GetDC and ReleaseDC functions must be used
• When the window is refreshed (e.g. after changing its size), only the code for the WM_PAINT message is called, this is the reason why the content is cleared

#include <list>
using namespace std;

static list<POINT> pointsList;

case WM_LBUTTONDOWN:
{
    POINT pt;
    pt.x = (short)LOWORD(lParam);
    pt.y = (short)HIWORD(lParam);
    pointsList.push_back(pt);
    InvalidateRect(hWnd, NULL, TRUE);
}
break;

case WM_PAINT:
{
    hdc = BeginPaint(hWnd, &ps);
    HBRUSH brush = CreateSolidBrush(RGB(128, 128, 0));
    HBRUSH oldBrush = (HBRUSH)SelectObject(hdc, brush);

    list<POINT>::const_iterator iter = pointsList.begin();
    while (iter != pointsList.end()) {
        POINT pt = *iter;
        const int rad = 5;
        Ellipse(hdc, pt.x - rad, pt.y - rad, pt.x + rad, pt.y + rad);
        iter++;
    }
 
    SelectObject(hdc, oldBrush);
    DeleteObject(brush);
    EndPaint(hWnd, &ps);
}
break;

• The InvalidateRect function sets the specified rectangle (or full client area when the NULL value is used) as a region that must be redrawn and inserts the WM_PAINT message to the message queue
• To force the window to redraw as soon as possible, call the UpdateWindow functions immediately after calling the InvalidateRect function

case WM_PAINT:
{
    hdc = BeginPaint(hWnd, &ps);
    RECT rc;
    GetClientRect(hWnd, &rc);
    HBRUSH oldBrush = (HBRUSH)SelectObject(hdc, (HBRUSH)GetStockObject(GRAY_BRUSH));
    Rectangle(hdc, 0, 0, rc.right, rc.bottom);
    SelectObject(hdc, (HBRUSH)GetStockObject(BLACK_BRUSH));
    const int margin = 50;
    Rectangle(hdc, margin, margin, rc.right - margin, rc.bottom - margin);
    SelectObject(hdc, oldBrush);
    EndPaint(hWnd, &ps);
}
break;

case WM_ERASEBKGND:
    return 1;

static HDC offDC = NULL;
static HBITMAP offOldBitmap = NULL;
static HBITMAP offBitmap = NULL;

case WM_CREATE:
    hdc = GetDC(hWnd);
    offDC = CreateCompatibleDC(hdc);
    ReleaseDC(hWnd, hdc);
    break;
 
case WM_SIZE:
{
    int clientWidth = LOWORD(lParam);
    int clientHeight = HIWORD(lParam);
    hdc = GetDC(hWnd);
 
    if (offOldBitmap != NULL) {
        SelectObject(offDC, offOldBitmap);
    }
    if (offBitmap !=- NULL) {
        DeleteObject(offBitmap);
    }
    offBitmap = CreateCompatibleBitmap(hdc, clientWidth, clientHeight);
    offOldBitmap = (HBITMAP)SelectObject(offDC, offBitmap);
 
    ReleaseDC(hWnd, hdc);
}
break;
 
case WM_PAINT:
{
    hdc = BeginPaint(hWnd, &ps);
    RECT rc;
    GetClientRect(hWnd, &rc);
    HBRUSH oldBrush = (HBRUSH)SelectObject(offDC, (HBRUSH)GetStockObject(GRAY_BRUSH));
    Rectangle(offDC, 0, 0, rc.right, rc.bottom);
    SelectObject(offDC, (HBRUSH)GetStockObject(BLACK_BRUSH));
    const int margin = 50;
    Rectangle(offDC, margin, margin, rc.right - margin, rc.bottom - margin);
    SelectObject(offDC, oldBrush);
 
    BitBlt(hdc, 0, 0, rc.right, rc.bottom, offDC, 0, 0, SRCCOPY);
    EndPaint(hWnd, &ps);
}
break;
 
case WM_ERASEBKGND:
    return 1;
 
case WM_DESTROY:
    if (offOldBitmap != NULL) {
        SelectObject(offDC, offOldBitmap);
    }
    if (offDC != NULL) {
        DeleteDC(offDC);
    }
    if (offBitmap != NULL) {
        DeleteObject(offBitmap);
    }
    PostQuitMessage(0);
    break;

• Explanations:
  • In response for the WM_CREATE message, a memory device context is created (it has no dependency on the size of the window, so there is no need to recreate it during responsing for the WM_SIZE message)
  • In response for the WM_SIZE message, a memory bitmap is created (so whenever the window changes its size, the bitmap is recreated - that's why resizing of the window is much slower for the above code)
  • If such slow resizing is unacceptable, a bitmap with the biggest possible size (use desktop's size) should be created in response for the WM_CREATE message
  • In the WM_PAINT message everything is painted on the memory device context and at the end copied to the screen device context using the BitBlt function
• This solution is not perfect - there is no response for changing the image depth of the display (in bits per pixel). The WM_DISPLAYCHANGE message should be used.