WINDOWS PROGRAMMING

WINDOWS PROGRAMMING:
Windows consists largely of three dynamic link libraries.

Kernel:
1) Responsible for Memory Management.
2) Loading and Executing Programs.
3) Scheduling.

User:
The user interface and windowing.

GDI: Graphical Device Interface.
a) Windows are created based on a "Window Class".
b) The Window class identifies the window procedure that processes messages to the window.
c) When a windows program begins execution, windows creates a "message queue" for the program.
d) The program includes a "message loop" to retrieve these messages from the queue and dispatch them to the appropriate window procedure.
e) "WinMain" is the entry point to the program.

QUEUE AND NON-QUEUED MESSAGES:
Queued messages are posted to a message queue while non-queued messages are sent to the window procedure.

FUNCTIONS:
 1) LoadIcon : Loads an icon for use by a program.
 2) LoadCursor : Loads a mouse cursor for use by a program.
 3) GetStockObject : Obtains a graphics object.
 4) RegisterClass : Registers a window class for the programs window.
 5) CreateWindow : Creates a window based on a window class.
 6) ShowWindow : Displays the window on the screen.
 7) UpdateWindow : Directs the window to paint itself.
 8) GetMessage : Obtains a message from the message queue.
 9) TranslateMessage : Translates some keyboard messages.
10) DispatchMessage  : Sends a message to a window procedure.
11) BeginPaint : Initiates the beginning of window painting.
12) GetClientRect : Obtains the dimensions of the windows client area.
13) DrawText : Displays a text string.
14) EndPaint : Ends window painting.
15) PostQuitMessage : Inserts a "quit" message into the message queue.
16) DefWindowProc : Performs default processing of messages.

STRUCTURE:
MSG - MESSAGE Structure
WINDOWS - Windows Class Structure
PAINTSTRUCT - Paint Structure
RECT -       Rectangle Structure

HANDLE:
HANDLE          -> Generic Handle
HWND -> Handle to a Window
HDC -> Handle to a Device Context
A handle is a number that windows uses for internal reference to an object.

DEVICE CONTEXT:
a) Device Context is the handle to the GDI Functions.
b) It is a data structure maintained by GDI.
c) It is associated with a particular display device.

There are four types of DCs: display, printer, memory (or compatible), and information. 

1) Display Device Contexts:
a) An application obtains a display DC by calling the BeginPaint, GetDC, or GetDCEx function and identifying the window in which the corresponding output will appear. 
i) BeginPaint - EndPaint
a) It Requires the handle to the window.
b) The address of a structure variable of type PAINTSTRUCT.
ii) GetDC function retrieves a handle to a device context (DC) for the client area of a specified window or for the entire screen.
 
b) An application obtains a window device context by calling the GetWindowDC function. The GetWindowDC function retrieves the device context (DC) for the entire window, including title bar, menus, and scroll bars.

c) When the application is finished drawing, it must release the DC by calling the EndPaint or ReleaseDC function.

2) Printer Device Contexts:
a) An application creates a printer DC by calling the CreateDC function and supplying the appropriate arguments. 
b) When an application has finished printing, it deletes the printer DC by calling the DeleteDC function. 
 
3) Memory Device Contexts: 
a) An application can create a memory DC by calling the CreateCompatibleDC function.
b) When you no longer need the memory DC, call the DeleteDC function

4) Information Device Contexts:
a) The information DC is used to retrieve default device data. For example, an application can call the CreateIC function
b) After an application finishes retrieving data by using an information DC, it must call the DeleteDC function.

Example:

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst;                                                        // current instance

WCHAR szTitle[MAX_LOADSTRING];                     // The title bar text

WCHAR szWindowClass[MAX_LOADSTRING];      // the main window class name

// Forward declarations of functions included in this code module:

ATOM                MyRegisterClass(HINSTANCE hInstance);

BOOL                InitInstance(HINSTANCE, int);

LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,

                     _In_opt_ HINSTANCE hPrevInstance,

                     _In_ LPWSTR    lpCmdLine,

                     _In_ int       nCmdShow)

{

            UNREFERENCED_PARAMETER(hPrevInstance);

            UNREFERENCED_PARAMETER(lpCmdLine);

            // Initialize global strings

            LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

            LoadStringW(hInstance, IDC_WINDOWSPROJECT1, szWindowClass, MAX_LOADSTRING);

            MyRegisterClass(hInstance);

            // Perform application initialization:

            if (!InitInstance (hInstance, nCmdShow))

            {

                    return FALSE;

            }

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

            MSG msg;

            // Main message loop:

            while (GetMessage(&msg, nullptr, 0, 0))

            {

                    if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

                    {

                            TranslateMessage(&msg);

                            DispatchMessage(&msg);

                    }

            }

            return (int) msg.wParam;

    }

    //

    //  FUNCTION: MyRegisterClass()

    //

    //  PURPOSE: Registers the 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_WINDOWSPROJECT1));

            wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);

            wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);

            wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WINDOWSPROJECT1);

            wcex.lpszClassName  = szWindowClass;

            wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

            return RegisterClassExW(&wcex);

    }

    //

    //   FUNCTION: InitInstance(HINSTANCE, int)

    //

    //   PURPOSE: Saves instance handle and creates main window

    //

    //   COMMENTS:

    //

    //        In this function, we save the instance handle in a global variable and

    //        create and display the main program window.

    //

    BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

    {

           hInst = hInstance; // Store instance handle in our global variable

           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;

    }

    //

    //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

    //

    //  PURPOSE: Processes messages for the main window.

    //

    //  WM_COMMAND  - process the application menu

    //  WM_PAINT    - Paint the main window

    //  WM_DESTROY  - post a quit message and return

    //

    //

    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

    {

            switch (message)

            {

                case WM_COMMAND:

                {

                     int wmId = LOWORD(wParam);

                    // Parse the menu selections:

                    switch (wmId)

                    {            

                        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 that uses hdc here...

                        EndPaint(hWnd, &ps);

                }

                break;

                case WM_DESTROY:

                        PostQuitMessage(0);

                break;

                default:

                        return DefWindowProc(hWnd, message, wParam, lParam);

        }

        return 0;

    }

Refer:  REMOTE PROCEDURE CALL