Win32

  
// Prog1_1 - A Hello World program written by hand

//           without the aid of modern convieniences

//           like AppWizard


#include <windows.h>

// prototype declarations

int WINAPI WinMain(
    HINSTANCE hInstance,     // handle of current instance

    HINSTANCE hPrevInstance, // handle of previous instance

    LPSTR     pszCmdLine,    // command line

    int       nCmdShow       // show state of window

    );

LRESULT CALLBACK WindowProc(
    HWND   hWnd,   // handle of window

    UINT   uMsgId, // message identifier

    WPARAM wParam, // first message parameter

    LPARAM lParam  // second message parameter

    );

// WinMain is always the first function to execute in a WinApp.

int WINAPI WinMain(
    HINSTANCE hInstance,     // handle of current instance


                             // is really a handle of the

                             // program. Can be used to

                             // access information about

                             // the program''s satus.


    HINSTANCE hPrevInstance, // handle of previous instance


                             // in windows 95 this is always

                             // 0 and is not used.


    LPSTR     pszCmdLine,    // command line


                             // is the command line that was

                             // used to call the application.

                             // ex: if you typed the DOS

                             // command WORDPAD MYFILE.TXT

                             // pszCmdLine would point to

                             // MYFILE.TXT. This is also the

                             // case when you drag and drop

                             // or double click on a file.


    int       nCmdShow       // show state of window


                             // this is how the initial

                             // window will be displayed.

                             // some values include:

                             // SW_SHOW-NORMAL

                             // SW_SHOWMINIMIZED

                             // SW_SHOWMAXIMIZED

    )
{
    static char szAppName[] = "Prog1";
    HWND hWnd;
    MSG msg;
    WNDCLASS wndClass;

    // fist register the window class


    // registering is important, and more than one window

    // can be created from a single window class.

    wndClass.style         = 0;
      // The style controls certain redraw characteristics

      // of the window. Constants carrying the prefix CS_

      // are #defined in windows.h for this purpose. For

      // example, setting style to CS_NOCLOSE before

      // registering the class disables the Close box on

      // the window frame and under the system menu icon.


      // each of these CS_flags is defined as a constant

      // with a single bit set to allow these properties

      // to be combined.


      // ex: wndClass.style = CS_DBLCLICK | CS_HREDRAW | CS_VREDRAW;


      // this assignment tells Windows to redraw the

      // entire window whenever the window is resized

      // in either the horizontal or vertical dimension

      // and to send double-click messages to the window.

    wndClass.lpfnWndProc   = WindowProc; // callback fn

      // is a pointer to a functions that is associated

      // with any window created with the newly registered

      // window class

    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = 0;
      // define the class and window extensions. Because

      // c++ provides a much better way to store this type

      // of information, set these values to zero.

    wndClass.hInstance     = hInstance;
      // is set to the instance handle of the current

      // application passed to you as the first argument

      // to WinMain(); this member enables Windows to

      //associate the window class with the proper program.

    wndClass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
      // the handle of the icon that is displayed when the

      // application is minimized or when the program is

      // examined in its folder. You can make your own or

      // use the default Windows ones. Some default ones

      // are IDI_ASTERISK, IDI_EXCLAMATION, IDI_HAND, and

      // IDI_QUESTION.

    wndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      // the handle of the bitmap that will be used for

      // cursor. Some defaults are: IDC_CROSS (a crosshair),

      // IDC_IBEAM, IDC_NO (a slashed circle), and IDC_WAIT

      // (an hourglass).

    wndClass.hbrBackground = (HBRUSH__*)GetStockObject(WHITE_BRUSH);
      // a brush which will paint the background of the

      // window. Can also be paterns.

    wndClass.lpszMenuName  = NULL;
      // points to the name of the menu class to be used

      // with this window class.

    wndClass.lpszClassName = szAppName;
      // is set to the name to be used for the window class.

    if (RegisterClass(&wndClass) == 0) // register class...

    {
       return 0;     // ...quit if it doesn''t work

    }

    // now create the app''s one window

    hWnd = CreateWindow(
             szAppName,           // the window class name

             szAppName,           // the window caption

                                  // appears in title bar

                                  // when window is displayed.

             WS_OVERLAPPEDWINDOW, // window syle

             CW_USEDEFAULT,       // horizontal position

             CW_USEDEFAULT,       // vertical position

             CW_USEDEFAULT,       // width

             CW_USEDEFAULT,       // height

             NULL,                // handle of parent or

                                  // owner window

             NULL,                // menu handle

             hInstance,           // program instance handle

             NULL);               // address of window

                                  // creation data

                                  // is always 0.

    if (hWnd == 0)
    {
       return 0;
    }
    ShowWindow(hWnd, nCmdShow);
      // the arguments are as follows: 1st-window to show.

      // 2nd-how to display it (minimized,normal or maximized).

    UpdateWindow(hWnd);
      // this is what in fact caused the hello world text to

      // be displayed. It causes a WM_PAINT message to be sent

      // to the application to ask it to repaint the window.


    // this is the message loop. it is like the macintosh

    // event loop. GetMessage will return true as long as

    // it receives messages other than WM_QUIT. Unless

    // specified otherwise, this will receive messages for

    // all windows for the window class.

    
    while (GetMessage(&msg, NULL, 0,0))
    {
       TranslateMessage(&msg);
         // this function converts some keyboard messages,

         // but for most message types has no effect.

       DispatchMessage(&msg);
         // asks Windows to pass the message to the message

         // handler for the window specified in the MSG

         // structure. (WindowProc)

    }
    return msg.wParam;
}

// WindowProc -- this function gets called

//               to process Windows messages

LRESULT CALLBACK WindowProc(
    HWND    hWnd,   // handle of window

    UINT    uMsgId, // message identifier

    WPARAM  wParam, // first message parameter

    LPARAM  lParam  // second message parameter

    )
{
    static char *pszHello = "Hello, world";

    // decide what to do with each different message

    // type

    switch (uMsgId)
    {
      // handle the window paint message by dispalying

      // the string "Hello, world" in the upper-left

      // corner (coord 0,0) of the window

      case WM_PAINT:
        // to process a WM_PAINT message, you must make

        // a call to make windows believe that the window

        // has been restored. In this case it is BeginPaint.

        // If you don''t call this, windows will keep calling

        // the WM_PAINT message in an infinite loop, trying

        // to get the window validated.

        HDC hDC;
        PAINTSTRUCT paintStruct;
        hDC = BeginPaint(hWnd, &paintStruct);
          // other functions to get the device context

          // include GetDC() to obtain a handle, and

          // ReleaseDC() when you are done. This funciton

          // pair does not validate the window, and it

          // sets the clipping region in the device

          // context to be the entire client area, not

          // just the invalid region.

          
          // this should only be called in response to

          // a WM_PAINT message. BeginPaint() sets the

          // clipping region of the device context to

          // be the same as the invalid region of the

          // window. That is, even if the application

          // attempts to repaint the entire window,

          // somewhere within Windows this attempt is

          // short-curcuited so thta only the parts

          // of the window that need to be updated

          // are then updated.


        // uses the current font

        TextOut(hDC,                // the device context to use

                0, 0,               // x,y location

                pszHello,           // string to write

                lstrlen(pszHello)); // string length


                                    // lstrlen is the windows

                                    // equivilent of strlen, and

                                    // functions quite the same

                                    // way, but accomodates 16-bit

                                    // Oriental character sets when

                                    // necessary.


        EndPaint(hWnd, &paintStruct);
          // destroy the device context to free up the

          // resources used (memory etc...). Note, you

          // cannot store the hDC, as it may become

          // invalid, and thus not work.

        return 0;

      // handle the window destroy message by quitting

      // the application

      case WM_DESTROY:
        // the destroy message is given when a window is

        // closed. In this case, since the app has only

        // 1 window, we will make it quit.

        PostQuitMessage(0);
          // this causes a WM_QUIT message to be generated.

          // this will make the program exit.

        return 0;

      default:
        // let Windows handle all other message types

        return DefWindowProc(hWnd,uMsgId,wParam,lParam);
    }
}