 Microsoft Windows S.D.K. v3.0 Sample `C' Source Code


 BITMAP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\BITMAP\BITMAP.C

 /****************************************************************************

     PROGRAM: Bitmap.c

     PURPOSE: Demonstrates how to use bitmap

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box
         MakeColorBitmap(HWND) - creates a color bitmap

     COMMENTS:

         This application is linked with select.exe which is a library
         module.  For the source code, look in the \select\ directory, and
         in Appendix C of the Windows Programmer's Learning Guide.

 ****************************************************************************/

 #include "windows.h"
 #include "bitmap.h"
  "select.h"                /* used to link with select.exe */

 HANDLE hInst;

 /* Patterns used for the background */

 short White[] =  { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
 short Black[] =  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 short Zigzag[] = { 0xFF, 0xF7, 0xEB, 0xDD, 0xBE, 0x7F, 0xFF, 0xFF };
 short CrossHatch[] = { 0xEF, 0xEF, 0xEF, 0xEF, 0x00, 0xEF, 0xEF, 0xEF };

 /* handles used for the various bitmaps */

 HBITMAP hPattern1;
 HBITMAP hPattern2;
 HBITMAP hPattern3;
 HBITMAP hPattern4;
 HBITMAP hBitmap1;
 HBITMAP hBitmap2;
 HBITMAP hBitmap3;
 HBITMAP hMenuBitmap1;
 HBITMAP hMenuBitmap2;
 HBITMAP hMenuBitmap3;
 HBITMAP hBitmap;
 HBITMAP hOldBitmap;

 HBRUSH hBrush;                         /* brush handle
 int fStretchMode;                      /* type of stretch mode to use

 HDC hDC;                               /* handle to device context
 HDC hMemoryDC;                         /* handle to memory device context
 BITMAP Bitmap;                         /* bitmap structure

 BOOL bTrack = FALSE;                   /* TRUE if user is selecting a region
 RECT Rect;

 /* The following variables keep track of which menu item is checked */

 WORD wPrevBitmap = IDM_BITMAP1;
 WORD wPrevPattern = IDM_PATTERN1;
 WORD wPrevMode = IDM_WHITEONBLACK;
 WORD wPrevItem;

 int Shape = SL_BLOCK;            /* shape to use for the selection rectangle

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = CS_VREDRAW | CS_HREDRAW;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "BitmapMenu";
     wc.lpszClassName = "BitmapWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hwnd;

     hInst = hInstance;

     hwnd = CreateWindow(
         "BitmapWClass",
         "Bitmap Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
         WM_CREATE      - create window and objects
         WM_LBUTTONDOWN - begin selection
         WM_MOUSEMOVE   - keep track of mouse movement during selection
         WM_LBUTTONUP   - end selection, draw bitmap
         WM_RBUTTONUP   - draw bitmap without resizing
         WM_ERASEBKGND  - erase background and redraw
         WM_DESTROY     - destroy window

     COMMENTS:

         User may select a "normal" size bitmap by pressing the right mouse
         button, or set the size of the bitmap to display by using the left
         button to define a region.  The routines to display the selection
         region are defined in the library module select.exe.
   WM_DESTROY    - destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     HMENU hMenu;
     HBRUSH hOldBrush;
     HBITMAP hOurBitmap;

     switch (message) {
         case WM_CREATE:                            /* message: create window

             hPattern1 = CreateBitmap(8, 8, 1, 1, (LPSTR) White);
             hPattern2 = CreateBitmap(8, 8, 1, 1, (LPSTR) Black);
             hPattern3 = CreateBitmap(8, 8, 1, 1, (LPSTR) Zigzag);
             hPattern4 = CreateBitmap(8, 8, 1, 1, (LPSTR) CrossHatch);

             hBitmap1 = LoadBitmap(hInst, "dog");
             hBitmap2 = LoadBitmap(hInst, "cat");
             hBitmap3 = MakeColorBitmap(hWnd);

             hMenuBitmap1 = LoadBitmap(hInst, "dog");
             hMenuBitmap2 = LoadBitmap(hInst, "cat");
             hMenuBitmap3 = MakeColorBitmap(hWnd);

             hMenu = CreateMenu();
       AppendMenu(hMenu, MF_STRING | MF_CHECKED, IDM_PATTERN1, "&White");
       AppendMenu(hMenu, MF_STRING, IDM_PATTERN2, "&Black");
             AppendMenu(hMenu, MF_BITMAP, IDM_PATTERN3,
            (LPSTR)(LONG)hPattern3);
             AppendMenu(hMenu, MF_BITMAP, IDM_PATTERN4,
            (LPSTR)(LONG)hPattern4);

       ModifyMenu(GetMenu(hWnd), 1, MF_POPUP | MF_BYPOSITION,
            (WORD)hMenu, "&Pattern");

             hMenu = CreateMenu();

             /* Use bitmaps for menu items */
             AppendMenu(hMenu, MF_BITMAP | MF_CHECKED, IDM_BITMAP1,
            (LPSTR)(LONG) hMenuBitmap1);
             AppendMenu(hMenu, MF_BITMAP, IDM_BITMAP2,
            (LPSTR)(LONG) hMenuBitmap2);
             AppendMenu(hMenu, MF_BITMAP, IDM_BITMAP3,
            (LPSTR)(LONG) hMenuBitmap3);
             ModifyMenu(GetMenu(hWnd), 0, MF_POPUP | MF_BYPOSITION,
                        (WORD) hMenu, "&Bitmap");

             hBrush = CreatePatternBrush(hPattern1);
             fStretchMode = IDM_BLACKONWHITE;

             /* Select the first bitmap */

             hDC = GetDC(hWnd);
             hMemoryDC = CreateCompatibleDC(hDC);
             ReleaseDC(hWnd, hDC);
             hOldBitmap = SelectObject(hMemoryDC, hBitmap1);
             GetObject(hBitmap1, 16, (LPSTR) &Bitmap);

             break;

         case WM_LBUTTONDOWN:           /* message: left mouse button pressed

             /* Start selection of region */

             bTrack = TRUE;
             SetRectEmpty(&Rect);
             StartSelection(hWnd, MAKEPOINT(lParam), &Rect,
                 (wParam & MK_SHIFT) ? (SL_EXTEND | Shape) : Shape);
             break;

         case WM_MOUSEMOVE:                        /* message: mouse movement

             /* Update the selection region */

             if (bTrack)
                 UpdateSelection(hWnd, MAKEPOINT(lParam), &Rect, Shape);
             break;

         case WM_LBUTTONUP:            /* message: left mouse button released

             if (bTrack) {
                /* End the selection */

                EndSelection(MAKEPOINT(lParam), &Rect);
                ClearSelection(hWnd, &Rect, Shape);

                hDC = GetDC(hWnd);
                SetStretchBltMode(hDC, fStretchMode);
                StretchBlt(hDC, Rect.left, Rect.top,
                    Rect.right - Rect.left, Rect.bottom - Rect.top,
                   hMemoryDC, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);
                ReleaseDC(hWnd, hDC);
             }

             bTrack = FALSE;
             break;

         case WM_RBUTTONUP:           /* message: right mouse button released

             /* Display a normal sized bitmap */

             hDC = GetDC(hWnd);
             BitBlt(hDC, LOWORD(lParam), HIWORD(lParam),
                 Bitmap.bmWidth, Bitmap.bmHeight, hMemoryDC, 0, 0, SRCCOPY);
             ReleaseDC(hWnd, hDC);
             break;

         case WM_ERASEBKGND:                    /* messsage: erase background

             /* Repaint the background */

             UnrealizeObject(hBrush);
             hOldBrush = SelectObject(wParam, hBrush);
             GetClientRect(hWnd, &Rect);
             PatBlt(wParam, Rect.left, Rect.top,
                 Rect.right-Rect.left, Rect.bottom-Rect.top, PATCOPY);
             SelectObject(wParam, hOldBrush);
             return TRUE;

   case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
         lpProcAbout = MakeProcInstance(About, hInst);
         DialogBox(hInst,
             "AboutBox",
             hWnd,
             lpProcAbout);
         FreeProcInstance(lpProcAbout);
         break;

                 case IDM_BITMAP1:
                     wPrevItem = wPrevBitmap;
                     wPrevBitmap = wParam;
                     GetObject(hBitmap1, 16, (LPSTR) &Bitmap);
                     SelectObject(hMemoryDC, hBitmap1);
                     break;

                 case IDM_BITMAP2:
                     wPrevItem = wPrevBitmap;
                     wPrevBitmap = wParam;
                     GetObject(hBitmap2, 16, (LPSTR) &Bitmap);
                     SelectObject(hMemoryDC, hBitmap2);
                     break;

                 case IDM_BITMAP3:
                     wPrevItem = wPrevBitmap;
                     wPrevBitmap = wParam;
                     GetObject(hBitmap3, 16, (LPSTR) &Bitmap);
                     hOurBitmap = SelectObject(hMemoryDC, hBitmap3);
                     break;

                 /* Pattern menu: select the background brush to use */

                 case IDM_PATTERN1:
                     wPrevItem = wPrevPattern;
                     wPrevPattern = wParam;
                     DeleteObject(hBrush);
                     hBrush = CreatePatternBrush(hPattern1);
                     InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
                     UpdateWindow(hWnd);
                     break;

                 case IDM_PATTERN2:
                     wPrevItem = wPrevPattern;
                     wPrevPattern = wParam;
                     DeleteObject(hBrush);
                     hBrush = CreatePatternBrush(hPattern2);
                     InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
                     UpdateWindow(hWnd);
                     break;

                 case IDM_PATTERN3:
                     wPrevItem = wPrevPattern;
                     wPrevPattern = wParam;
                     DeleteObject(hBrush);
                     hBrush = CreatePatternBrush(hPattern3);
                     InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
                     UpdateWindow(hWnd);
                     break;

                 case IDM_PATTERN4:
                     wPrevItem = wPrevPattern;
                     wPrevPattern = wParam;
                     DeleteObject(hBrush);
                     hBrush = CreatePatternBrush(hPattern4);
                     InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
                     UpdateWindow(hWnd);
                     break;

                 /* Mode menu: select the stretch mode to use */

                 case IDM_BLACKONWHITE:
                     wPrevItem = wPrevMode;
                     wPrevMode = wParam;
                     fStretchMode = BLACKONWHITE;
                     break;

                 case IDM_WHITEONBLACK:
                     wPrevItem = wPrevMode;
                     wPrevMode = wParam;
                     fStretchMode = WHITEONBLACK;
                     break;

                 case IDM_COLORONCOLOR:
                     wPrevItem = wPrevMode;
                     wPrevMode = wParam;
                     fStretchMode = COLORONCOLOR;
                     break;
             }

             /* Uncheck the old item, check the new item */

             CheckMenuItem(GetMenu(hWnd), wPrevItem, MF_UNCHECKED);
             CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
             break;


   case WM_DESTROY:
             SelectObject(hMemoryDC, hOldBitmap);
             DeleteDC(hMemoryDC);
             DeleteObject(hBrush);
             DeleteObject(hPattern1);
             DeleteObject(hPattern2);
             DeleteObject(hPattern3);
             DeleteObject(hPattern4);
             DeleteObject(hBitmap1);
             DeleteObject(hBitmap2);
             DeleteObject(hBitmap3);
             DeleteObject(hMenuBitmap1);
             DeleteObject(hMenuBitmap2);
             DeleteObject(hMenuBitmap3);

       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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



 /****************************************************************************

     FUNCTION: MakeColorBitmap(HWND)

     PURPOSE: Creates a color bitmap

     COMMENTS:

         This creates a plaid color bitmap by using overlappying colors.

 ****************************************************************************/

 HBITMAP MakeColorBitmap(hWnd)
 HWND hWnd;
 {
     HDC hDC;
     HDC hMemoryDC;
     HBITMAP hBitmap;
     HBITMAP hOldBitmap;
     HBRUSH hRedBrush;
     HBRUSH hGreenBrush;
     HBRUSH hBlueBrush;
     HBRUSH hOldBrush;

     hDC = GetDC(hWnd);
     hMemoryDC = CreateCompatibleDC(hDC);
     hBitmap = CreateCompatibleBitmap(hDC, 64, 32);
     hOldBitmap = SelectObject(hMemoryDC, hBitmap);
     hRedBrush = CreateSolidBrush(RGB(255,0,0));
     hGreenBrush = CreateSolidBrush(RGB(0,255,0));
     hBlueBrush = CreateSolidBrush(RGB(0,0,255));

     PatBlt(hMemoryDC, 0, 0, 64, 32, BLACKNESS);
     hOldBrush = SelectObject(hMemoryDC, hRedBrush);
     PatBlt(hMemoryDC, 0, 0, 24, 11, PATORDEST);
     PatBlt(hMemoryDC, 40, 10, 24, 12, PATORDEST);
     PatBlt(hMemoryDC, 20, 21, 24, 11, PATORDEST);
     SelectObject(hMemoryDC, hGreenBrush);
     PatBlt(hMemoryDC, 20, 0, 24, 11, PATORDEST);
     PatBlt(hMemoryDC, 0, 10, 24, 12, PATORDEST);
     PatBlt(hMemoryDC, 40, 21, 24, 11, PATORDEST);
     SelectObject(hMemoryDC, hBlueBrush);
     PatBlt(hMemoryDC, 40, 0, 24, 11, PATORDEST);
     PatBlt(hMemoryDC, 20, 10, 24, 12, PATORDEST);
     PatBlt(hMemoryDC, 0, 21, 24, 11, PATORDEST);

     SelectObject(hMemoryDC, hOldBrush);
     DeleteObject(hRedBrush);
     DeleteObject(hGreenBrush);
     DeleteObject(hBlueBrush);
     SelectObject(hMemoryDC, hOldBitmap);
     DeleteDC(hMemoryDC);
     ReleaseDC(hWnd, hDC);
     return (hBitmap);
 }


 CFONT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWFONT\CFONT.C

 /****************************************************************************
     MODULE: cfont.c

     FUNCTION: CFontDlg(HWND, unsigned, WORD, LONG);

     PURPOSE: Processes dialog box messages for creating a font

 ****************************************************************************/

 #include "windows.h"
 #include "showfont.h"

 BOOL FAR PASCAL CFontDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       SetDlgItemInt(hDlg, ID_HEIGHT, CLogFont.lfHeight, TRUE);
       SetDlgItemInt(hDlg, ID_WIDTH, CLogFont.lfWidth, TRUE);
       SetDlgItemInt(hDlg, ID_ESCAPEMENT,
     CLogFont.lfEscapement, TRUE);
       SetDlgItemInt(hDlg, ID_ORIENTATION,
     CLogFont.lfOrientation, TRUE);
       SetDlgItemText(hDlg, ID_FACE, CLogFont.lfFaceName);
       CheckDlgButton(hDlg, ID_ITALIC, CLogFont.lfItalic);
       CheckDlgButton(hDlg, ID_UNDERLINE, CLogFont.lfUnderline);
       CheckDlgButton(hDlg, ID_STRIKEOUT, CLogFont.lfStrikeOut);

       SetDlgItemInt(hDlg, ID_WEIGHT, CLogFont.lfWeight, TRUE);
       switch (CLogFont.lfWeight) {
     case FW_LIGHT:
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_LIGHT);
         break;

     case FW_NORMAL:
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_NORMAL);
         break;

     case FW_BOLD:
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_BOLD);
         break;
       }

       SetDlgItemInt(hDlg, ID_CHARSET, CLogFont.lfCharSet, TRUE);
       switch (CLogFont.lfCharSet) {
     case ANSI_CHARSET:
         CheckRadioButton(hDlg, ID_ANSI, ID_OEM, ID_ANSI);
         break;

     case OEM_CHARSET:
         CheckRadioButton(hDlg, ID_ANSI, ID_OEM, ID_OEM);
         break;
       }

       switch (CLogFont.lfOutPrecision) {
     case OUT_STRING_PRECIS:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_STRING);
         break;

     case OUT_CHARACTER_PRECIS:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_CHAR);
         break;

     case OUT_STROKE_PRECIS:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_STROKE);
         break;

     case OUT_DEFAULT_PRECIS:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_DEFAULT);
         break;
       }

       switch (CLogFont.lfClipPrecision) {
     case CLIP_CHARACTER_PRECIS:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_CHAR);
         break;

     case CLIP_STROKE_PRECIS:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_STROKE);
         break;

     case CLIP_DEFAULT_PRECIS:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_DEFAULT);
         break;
       }

       switch (CLogFont.lfQuality) {
     case PROOF_QUALITY:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY, ID_PROOF);
         break;

     case DRAFT_QUALITY:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY, ID_DRAFT);
         break;

     case DEFAULT_QUALITY:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY,
       ID_DEF_QUALITY);
         break;
       }

       switch ((CLogFont.lfPitchAndFamily) & 3) {
     case FIXED_PITCH:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH, ID_FIXED);
         break;

     case VARIABLE_PITCH:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH, ID_VARIABLE);
         break;

     case DEFAULT_PITCH:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH,
       ID_DEF_PITCH);
         break;
       }

       switch ((CLogFont.lfPitchAndFamily) & 240) {
     case FF_ROMAN:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_ROMAN);
         break;

     case FF_SWISS:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_SWISS);
         break;

     case FF_MODERN:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_MODERN);
         break;

     case FF_SCRIPT:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_SCRIPT);
         break;

     case FF_DECORATIVE:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_DECO);
         break;

     case FF_DONTCARE:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY,
       ID_DEF_FAMILY);
         break;
       }
       break;

   case WM_COMMAND:
       switch (wParam) {
     case IDOK:
         CLogFont.lfHeight = GetDlgItemInt(hDlg,
       ID_HEIGHT, NULL, TRUE);
         CLogFont.lfWidth = GetDlgItemInt(hDlg,
       ID_WIDTH, NULL, TRUE);
         CLogFont.lfEscapement = GetDlgItemInt(hDlg,
       ID_ESCAPEMENT, NULL, FALSE);
         CLogFont.lfOrientation = GetDlgItemInt(hDlg,
       ID_ORIENTATION, NULL, FALSE);
         GetDlgItemText(hDlg, ID_FACE, CLogFont.lfFaceName, 32);
         CLogFont.lfWeight = GetDlgItemInt(hDlg,
       ID_WEIGHT, NULL, FALSE);
         CLogFont.lfCharSet = GetDlgItemInt(hDlg,
       ID_CHARSET, NULL, FALSE);
         EndDialog(hDlg, 1);
         break;

     case IDCANCEL:
         EndDialog(hDlg, 0);
         break;

     case ID_ITALIC:
         CLogFont.lfItalic = IsDlgButtonChecked(hDlg, ID_ITALIC);
         break;

     case ID_UNDERLINE:
         CLogFont.lfUnderline = IsDlgButtonChecked(hDlg,
       ID_UNDERLINE);
         break;

     case ID_STRIKEOUT:
         CLogFont.lfStrikeOut = IsDlgButtonChecked(hDlg,
       ID_STRIKEOUT);
         break;

     case ID_LIGHT:
         SetDlgItemInt(hDlg, ID_WEIGHT, CLogFont.lfWeight, TRUE);
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_LIGHT);
         CLogFont.lfWeight = FW_LIGHT;
         break;

     case ID_NORMAL:
         SetDlgItemInt(hDlg, ID_WEIGHT, CLogFont.lfWeight, TRUE);
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_NORMAL);
         CLogFont.lfWeight = FW_NORMAL;
         break;

     case ID_BOLD:
         SetDlgItemInt(hDlg, ID_WEIGHT, CLogFont.lfWeight, TRUE);
         CheckRadioButton(hDlg, ID_LIGHT, ID_BOLD, ID_BOLD);
         CLogFont.lfWeight = FW_BOLD;
         break;

     case ID_WEIGHT:
         CheckDlgButton(hDlg, ID_LIGHT, FALSE);
         CheckDlgButton(hDlg, ID_NORMAL, FALSE);
         CheckDlgButton(hDlg, ID_BOLD, FALSE);
         break;

     case ID_ANSI:
         SetDlgItemInt(hDlg, ID_CHARSET, CLogFont.lfCharSet, TRUE);
         CheckRadioButton(hDlg, ID_ANSI, ID_OEM, ID_ANSI);
         break;

     case ID_OEM:
         SetDlgItemInt(hDlg, ID_CHARSET, CLogFont.lfCharSet, TRUE);
         CheckRadioButton(hDlg, ID_ANSI, ID_OEM, ID_OEM);
         break;

     case ID_CHARSET:
         CheckDlgButton(hDlg, ID_ANSI, FALSE);
         CheckDlgButton(hDlg, ID_OEM, FALSE);
         break;

     case ID_OUT_STRING:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_STRING);
         CLogFont.lfOutPrecision = OUT_STRING_PRECIS;
         break;

     case ID_OUT_CHAR:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_CHAR);
         CLogFont.lfOutPrecision = OUT_CHARACTER_PRECIS;
         break;

     case ID_OUT_STROKE:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_STROKE);
         CLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
         break;

     case ID_OUT_DEFAULT:
         CheckRadioButton(hDlg, ID_OUT_STRING, ID_OUT_DEFAULT,
       ID_OUT_DEFAULT);
         CLogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
         break;

     case ID_CLIP_CHAR:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_CHAR);
         CLogFont.lfClipPrecision = CLIP_CHARACTER_PRECIS;
         break;

     case ID_CLIP_STROKE:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_STROKE);
         CLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
         break;

     case ID_CLIP_DEFAULT:
         CheckRadioButton(hDlg, ID_CLIP_CHAR, ID_CLIP_DEFAULT,
       ID_CLIP_DEFAULT);
         CLogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
         break;

     case ID_PROOF:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY, ID_PROOF);
         CLogFont.lfQuality = PROOF_QUALITY;
         break;

     case ID_DRAFT:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY, ID_DRAFT);
         CLogFont.lfQuality = DRAFT_QUALITY;
         break;

     case ID_DEF_QUALITY:
         CheckRadioButton(hDlg, ID_PROOF, ID_DEF_QUALITY,
       ID_DEF_QUALITY);
         CLogFont.lfQuality = DEFAULT_QUALITY;
         break;

     case ID_FIXED:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH, ID_FIXED);
         CLogFont.lfPitchAndFamily =
       (~3 & CLogFont.lfPitchAndFamily) | FIXED_PITCH;
         break;

     case ID_VARIABLE:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH, ID_VARIABLE);
         CLogFont.lfPitchAndFamily =
       (~3 & CLogFont.lfPitchAndFamily) | VARIABLE_PITCH;
         break;

     case ID_DEF_PITCH:
         CheckRadioButton(hDlg, ID_FIXED, ID_DEF_PITCH,
       ID_DEF_PITCH);
         CLogFont.lfPitchAndFamily =
       (~3 & CLogFont.lfPitchAndFamily) | DEFAULT_PITCH;
         break;

     case ID_ROMAN:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_ROMAN);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_ROMAN;
         break;

     case ID_SWISS:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_SWISS);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_SWISS;
         break;

     case ID_MODERN:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_MODERN);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_MODERN;
         break;

     case ID_SCRIPT:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_SCRIPT);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_SCRIPT;
         break;

     case ID_DECO:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY, ID_DECO);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_DECORATIVE;
         break;

     case ID_DEF_FAMILY:
         CheckRadioButton(hDlg, ID_ROMAN, ID_DEF_FAMILY,
       ID_DEF_FAMILY);
         CLogFont.lfPitchAndFamily =
       (~240 & CLogFont.lfPitchAndFamily) | FF_DONTCARE;
         break;

       }
       break;
        }
        return (FALSE);
 }


 CLIDATA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\CLIDATA.C

 /****************************************************************************

     MODULE: CLIDATA.C

     PURPOSE: Maintains conversation data and paints data in the client
        application window.

 ****************************************************************************/

 #include "windows.h"
 #include "clires.h"
 #include "client.h"
 #include <string.h>
 #include <stdlib.h>

 typedef struct ITEM
 {
     char szItem[ITEM_MAX_SIZE+1];
     char szValue[VALUE_MAX_SIZE+1];
 };

 typedef struct CONV
 {
     BOOL  bInTerminate;
     enum PENDINGACK ePendingAck;
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char  szApplication[APP_MAX_SIZE+1];
     char  szTopic[TOPIC_MAX_SIZE+1];
     int   nItemCount;
     struct ITEM Item[ITEMS_PER_CONV_MAX_COUNT];
 };

 static struct CONV Conv[CONV_MAX_COUNT];
 static int   nConvCount = 0;
 static HWND  hwndNewClientDDE; /* used by SelectNewConvDlgProc */
 static HWND  hwndNewServerDDE; /* new conversation selected by user */

 static char  szSelectedApplication[APP_MAX_SIZE+1];
 static char  szSelectedTopic[TOPIC_MAX_SIZE+1];
 static char  szSelectedItem[ITEM_MAX_SIZE+1];
 static char  szSelectedValue[VALUE_MAX_SIZE+1];

 static struct CONV * NEAR FindConv(HWND);
 static struct ITEM * NEAR FindItem(HWND, char *);

 BOOL FAR PASCAL SelectNewConvDlgProc(HWND, unsigned, WORD, LONG);

 /*****************************************************************

     FUNCTION: AddItemToConv

     PURPOSE:  Add a data item to an existing conversation.

 *****************************************************************/
 BOOL AddItemToConv(hwndClientDDE, szItem)
     HWND   hwndClientDDE;
     char * szItem;
 {
     struct CONV * pConv;
     struct ITEM * pItem;

     if (!(pConv = FindConv(hwndClientDDE)))
         return (FALSE);
     if (pConv->nItemCount >= ITEMS_PER_CONV_MAX_COUNT)
         return (FALSE);
    pItem =  pConv->Item + pConv->nItemCount++;
    strcpy(pItem->szItem, szItem);
    pItem->szValue[0] = 0;
    return (TRUE);
 }




 /**********************************************************

     FUNCTION:  AtLeastOneConvActive

     PURPOSE:   Used during termination of application, to
          determine whether pending DDE terminations
          have completed.

 ***********************************************************/
 BOOL AtLeastOneConvActive()
 {
     return (nConvCount? TRUE: FALSE);
 }



 /*****************************************************************

     FUNCTION: AddConv

     PURPOSE:  Initialize items in CONV structure.

 *****************************************************************/
 BOOL AddConv(hwndClientDDE, hwndServerDDE, szApplication, szTopic)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szApplication;
     char * szTopic;
 {
     struct CONV * pConv;

     if (nConvCount >= CONV_MAX_COUNT)
         return (FALSE);
     pConv = Conv + nConvCount++;
     pConv->bInTerminate = FALSE;
     pConv->ePendingAck = NONE;
     pConv->hwndClientDDE = hwndClientDDE;
     pConv->hwndServerDDE = hwndServerDDE;
     strcpy(pConv->szApplication, szApplication);
     strcpy(pConv->szTopic, szTopic);
     pConv->nItemCount = 0;
     return (TRUE);
 }



 /*****************************************************************

     FUNCTION: DoesAdviseAlreadyExist

     PURPOSE:  Determines whether hot/warm link has already been
         established for specified conversation item.

 *****************************************************************/
 BOOL DoesAdviseAlreadyExist(hwndClientDDE, szItem)
     HWND hwndClientDDE;
     char * szItem;
 {
     return (FindItem(hwndClientDDE,szItem)==NULL?FALSE:TRUE);
 }



 /*****************************************************************

     FUNCTION: FindItem

     PURPOSE:  Return pointer to item structure given conversation and item.

 *****************************************************************/
 struct ITEM * NEAR FindItem(hwndClientDDE, szItem)
     HWND hwndClientDDE;
     char * szItem;
 {
     struct CONV * pConv;
     struct ITEM * pItem;
     int           nItemIndex;

     if (!(pConv = FindConv(hwndClientDDE)))
         return (NULL);
     for (pItem = pConv->Item, nItemIndex = 0;
    nItemIndex < pConv->nItemCount;
          pItem++, nItemIndex++)
     {
         if (!strcmpi(szItem, pItem->szItem))
         {
             return (pItem);
         }
     }
     return (NULL);
 }


 /*****************************************************************

     FUNCTION: FindConv

     PURPOSE:  Return pointer to conversation structure given handle
         to client DDE window.

 *****************************************************************/
 struct CONV * NEAR FindConv(hwndClientDDE)
     HWND  hwndClientDDE;
 {
     struct CONV * pConv;
     int     nConvIndex;

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE)
       return (pConv);
     }
     return (NULL);
 }


 /***************************************************************

     FUNCTION:  FindConvGivenAppTopic

     PURPOSE:   Find handle of client DDE window given
          application and topic for an active conversation.

 ***************************************************************/
 HWND FindConvGivenAppTopic(szApp, szTopic)
     char * szApp;
     char * szTopic;
 {
     struct CONV * pConv;
     int     nConvIndex;

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
    if (!(stricmp(pConv->szApplication, szApp))
        && !(stricmp(pConv->szTopic, szTopic)))
    {
        return pConv->hwndClientDDE;
    }
     }
     return NULL;
 }


 /*****************************************************************

     FUNCTION: GetAppAndTopic

     PURPOSE:  Get conversation's application and topic strings.

 *****************************************************************/
 void GetAppAndTopic(hwndClientDDE, szApp, szTopic)
     HWND  hwndClientDDE;
     char * szApp;
     char * szTopic;
 {
     struct CONV * pConv;

     if (!(pConv = FindConv(hwndClientDDE)))
         return;
     strcpy(szApp, pConv->szApplication);
     strcpy(szTopic, pConv->szTopic);
     return;
 }



 /****************************************************************

     FUNCTION: GetConvPendingAck

     PURPOSE:  Return state of acknowledgement for specified
         conversation.

 ****************************************************************/
 enum PENDINGACK GetConvPendingAck(hwndClientDDE)
     HWND hwndClientDDE;
 {
     struct CONV * pConv;

     if (pConv = FindConv(hwndClientDDE))
   return pConv->ePendingAck;
     else
         return NONE;
 }



 /*****************************************************************

     FUNCTION: GetHwndServerDDE

     PURPOSE:  Gets the hwnd of the server, given the handle of
         the client DDE window.

 *****************************************************************/
 HWND GetHwndServerDDE(hwndClientDDE)
     HWND  hwndClientDDE;
 {
     struct CONV * pConv;
     int  nConvIndex;

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE)
       return (pConv->hwndServerDDE);
     }
     return (NULL);
 }



 /*****************************************************************

     FUNCTION: GetNextConv

     PURPOSE:  Get next conversation in the list of current conversations.
         To get the first conversation, pass a NULL hwnd.

 *****************************************************************/
 HWND GetNextConv(hwndClientDDE)
     HWND hwndClientDDE;
 {
     struct CONV * pConv;
     int     nConvIndex;

     if (hwndClientDDE)
     {
   for (nConvIndex = 0, pConv = Conv;
        nConvIndex < nConvCount;
        nConvIndex++, pConv++)
         {
       if (pConv->hwndClientDDE == hwndClientDDE)
             {
     if (++nConvIndex < nConvCount)
         return (++pConv)->hwndClientDDE;
                 else
                     return (NULL);
             }
         }
         return (NULL);
     }
     if (nConvCount > 0)
   return (Conv[0].hwndClientDDE);
     else
         return (NULL);
 }



 /****************************************************************

     FUNCTION: HexToInt

     PURPOSE:  Convert from ascii to integer up to 4 chars
         representing a hexidecimal number.  The hex number
         is considered terminated by a null or any non-hex
         digit.

 ****************************************************************/
 int HexToInt(szHex)
     char * szHex;
 {
     unsigned int  nReturn;
     int     nDigit;
     int     nIndex;

     nReturn = 0;
     for (nIndex = 0; nIndex < 4; nIndex++)
     {
   if (*szHex >= '0' && *szHex <= '9')
       nDigit = *szHex - '0';
   else if (*szHex >= 'A' && *szHex <= 'F')
       nDigit = *szHex - 'A' + 10;
   else if (*szHex >= 'a' && *szHex <= 'f')
       nDigit = *szHex - 'a' + 10;
   else
       return ((int)nReturn);
   nReturn = (nReturn<<4) + nDigit;
   szHex++;
     }
     return ((int)nReturn);
 }




 /****************************************************************

     FUNCTION: IsConvInTerminateState

     PURPOSE:  Determine whether conversation is in process of
         being terminated.   In identifying the conversation,
         it is necessary to compare both the hwndClientDDE
         and hwndServerDDE, because during an initiate,
         there may be multiple unwanted conversations sharing
         the same hwndClientDDE.

 ****************************************************************/
 BOOL IsConvInTerminateState(hwndClientDDE, hwndServerDDE)
     HWND hwndClientDDE;
     HWND hwndServerDDE;
 {
     struct CONV * pConv;
     int  nConvIndex;

     for (nConvIndex = 0, pConv = Conv;
    nConvIndex < nConvCount;
    nConvIndex++, pConv++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE
       && pConv->hwndServerDDE == hwndServerDDE)
       return pConv->bInTerminate;
     }
     return (TRUE);  /* If conversation not found, assume terminate state */
         /* to avoid possible endless terminate feedback loop */
 }



 /****************************************************************

     FUNCTION: IsHwndClientDDEUsed

     PURPOSE:  Determine whether hwndClientDDE is still being
         used in some second conversation after the
         first conversation has been terminated.  This
         determination is necessary during an initiate
         in which the same hwndClientDDE is used in
         multiple WM_DDE_INITIATE messages.
         being terminated.

 ****************************************************************/
 BOOL IsHwndClientDDEUsed(hwndClientDDE)
     HWND  hwndClientDDE;
 {
     struct CONV * pConv;
     int  nConvIndex;

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE)
       return (TRUE);
     }
     return (FALSE);
 }



 /****************************************************************

     FUNCTION: LetUserPickConversation

     PURPOSE:  The client has initiated possibly multiple
         conversations (if a wild card application or topic
         was specified in the WM_DDE_INITIATE).  This function
         determines whether multiple servers established
         conversations with the specified hwndClientDDE.
         If so, this function asks the user to pick one of
         the conversations, and terminates the other
         conversations.

 ****************************************************************/
 BOOL LetUserPickConversation(hwndClientDDE)
     HWND  hwndClientDDE;
 {
     struct CONV * pConv;
     FARPROC  lpfnDlgProc;
     int  nCountSameWnd;
     int  nConvIndex;

     nCountSameWnd = 0;
     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE)
       nCountSameWnd++;
     }
     if (nCountSameWnd == 1)
   return (TRUE);
     if (nCountSameWnd == 0)
   return (FALSE);
     hwndNewServerDDE = NULL;
     hwndNewClientDDE = hwndClientDDE; /* make known to SelectNewConvDlgProc *
     /* Dialog proc SelectNewConvDlgProc is defined in this module */
     lpfnDlgProc = MakeProcInstance(SelectNewConvDlgProc, hInst);
     DialogBox(hInst,
         "SelectNewConversation",
         hwndMain,
         lpfnDlgProc);
     FreeProcInstance(lpfnDlgProc);

     /* Terminate unwanted conversations.  The only conversation  */
     /* wanted is the one (hwndNewServerDDE) selected by the user */
     /* in the SelectNewConv dialog box.        */

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE
       && pConv->hwndServerDDE != hwndNewServerDDE)
   {
       SendTerminate(hwndClientDDE, pConv->hwndServerDDE);
   }
     }
     return (TRUE);

 }


 /****************************************************************

     FUNCTION: PaintConvData

     PURPOSE:  Paint the client application window, using all
         conversation/item information.

 ****************************************************************/
 void PaintConvData(hwnd)
     HWND  hwnd;
 {
     HDC  hDC;
     PAINTSTRUCT ps;
     int  x,y;
     int  nConvIndex, nItemIndex;
     struct CONV * pConv;
     struct ITEM * pItem;
     char          szNumber[10];

     BeginPaint(hwnd, (LPPAINTSTRUCT)&ps);
     hDC = ps.hdc;

     y = yDelta/2;  /* start 1/2 line down window */

     for (pConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pConv++, nConvIndex++)
     {
   x = xDelta/2;  /* start 1/2 char across window */
         TextOut(hDC, x, y,
       (LPSTR)pConv->szApplication,
       strlen(pConv->szApplication));
         x += ((3+APP_MAX_SIZE)*xDelta);
         TextOut(hDC, x, y,
       (LPSTR)pConv->szTopic,
       strlen(pConv->szTopic));
         x += ((3+TOPIC_MAX_SIZE) *xDelta);
   itoa(pConv->hwndClientDDE, szNumber, 16);
   strupr(szNumber);
         TextOut(hDC, x, y, (LPSTR)szNumber, strlen(szNumber));
         y += yDelta;

   for (pItem = pConv->Item, nItemIndex = 0;
        nItemIndex < pConv->nItemCount;
              pItem++, nItemIndex++)
         {
             x = 4 * xDelta;   /* Indent items 4 spaces */
             TextOut(hDC, x, y,
                 (LPSTR)pItem->szItem,
                 strlen(pItem->szItem));
             x += ((3+ITEM_MAX_SIZE)*xDelta);
             TextOut(hDC, x, y,
                 (LPSTR)pItem->szValue,
                 strlen(pItem->szValue));
             y += yDelta;
         }

     }

     ValidateRect(hwnd, (LPRECT)NULL);
     EndPaint(hwnd, (LPPAINTSTRUCT)&ps);

     return;
 }



 /*****************************************************************

     FUNCTION: RemoveItemFromConv

     PURPOSE:  Remove an item (advise) from an existing conversation.

 *****************************************************************/
 BOOL RemoveItemFromConv(hwndClientDDE, szItem)
     HWND   hwndClientDDE;
     char * szItem;
 {
     struct CONV * pConv;
     int           nItemIndex;
     struct ITEM * pItem;

     if (!(pConv = FindConv(hwndClientDDE)))
         return (FALSE);
     pItem = pConv->Item;
     nItemIndex = 0;
     while (nItemIndex < pConv->nItemCount)
     {
         if (!(strcmpi(pItem->szItem, szItem)))
             break;
         pItem++;
         nItemIndex++;
     }
     pConv->nItemCount--;
     while (nItemIndex < pConv->nItemCount)
     {
         *pItem = *(pItem+1);
         pItem++;
         nItemIndex++;
     }
     return (TRUE);
 }



 /*****************************************************************

     FUNCTION: RemoveConv

     PURPOSE:  Remove active conversation.   It is necessary to
         specify both the client and server DDE windows,
         since during an initiate, only the server DDE
         window handles are distinguishable.

 *****************************************************************/
 BOOL RemoveConv(hwndClientDDE, hwndServerDDE)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
 {
     struct CONV * pRemoveConv;
     struct CONV * pConv;
     int     nConvIndex;

     for (pRemoveConv = Conv, nConvIndex = 0;
    nConvIndex < nConvCount;
    pRemoveConv++, nConvIndex++)
     {
   if (pRemoveConv->hwndClientDDE == hwndClientDDE
       && pRemoveConv->hwndServerDDE == hwndServerDDE)
       break;
     }
     if (nConvIndex >= nConvCount)
         return (FALSE);
     nConvIndex = 0;
     pConv = Conv;
     while (pConv != pRemoveConv)
     {
   if (++nConvIndex >= nConvCount)
             return (FALSE);
   pConv++;
     }
     while (++nConvIndex < nConvCount)
     {
   *pConv = *(pConv+1);
   pConv++;
     }
     nConvCount--;
     return (TRUE);
 }




 /****************************************************************

     FUNCTION: SelectNewConvDlgProc

     PURPOSE:  Ask the user to select one of multiple conversations
         that were established during a wild card initiate.

 ****************************************************************/
 BOOL FAR PASCAL SelectNewConvDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND hctlConvBox;
     struct CONV * pConv;
     int  nConvIndex;
     char szConvInfo[CONVINFO_MAX_SIZE];
     char * pcBlank;
     int    nIndex;

     switch (message)
     {
   case WM_INITDIALOG:
       hctlConvBox = GetDlgItem(hdlg, IDC_CONVBOX);
       SendMessage(hctlConvBox, LB_RESETCONTENT, 0, 0L);
       for (pConv = Conv, nConvIndex = 0;
      nConvIndex < nConvCount;
      pConv++, nConvIndex++)
       {
     /* If this is one of the newly initiated conversations */
     /* then add it to the list box.            */
     if (pConv->hwndClientDDE == hwndNewClientDDE)
     {
         /* Display server's DDE window in the list box, */
         /* as that is the only way to distinguish      */
         /* conversations at this point.        */
         itoa((int)pConv->hwndServerDDE, szConvInfo, 16);
         strupr(szConvInfo);
         strcat(szConvInfo, " ");
         strcat(szConvInfo, pConv->szApplication);
         strcat(szConvInfo, " | ");
         strcat(szConvInfo, pConv->szTopic);

         SendMessage(hctlConvBox,
       LB_ADDSTRING,
       0,
       (LONG)(LPSTR)szConvInfo);
     }
       }
       return (TRUE);

   case WM_COMMAND:
       switch (wParam)
       {
     case IDC_CANCEL:
         /* Function LetUserPickConveresation will terminate */
         /* all newly initiated conversations.    */
         hwndNewServerDDE = NULL;
         EndDialog(hdlg, FALSE);
         return (TRUE);

     case IDC_OK:
         /* Function LetUserPickConversation will terminate */
         /* all newly initiated conversations, except the   */
         /* one selected by the user: hwndNewServerDDE.     */
         hwndNewServerDDE = NULL;
         hctlConvBox = GetDlgItem(hdlg, IDC_CONVBOX);
         if ((nIndex = SendMessage(hctlConvBox,
                 LB_GETCURSEL, 0, 0L))
       != LB_ERR)
         {
       szConvInfo[0] = 0;
       SendMessage(hctlConvBox,
           LB_GETTEXT,
           nIndex,
           (LONG)(LPSTR)szConvInfo);
       if (pcBlank = strchr(szConvInfo, ' '))
       {
           *pcBlank = 0; /* terminate hwnd numeric value */
           hwndNewServerDDE = HexToInt(szConvInfo);
       }
         }
         EndDialog(hdlg, TRUE);
         return (TRUE);

     default:
         return (FALSE);
       }
     }
     return (FALSE);
 }



 /****************************************************************

     FUNCTION: SetConvInTerminateState

     PURPOSE:  Set conversation terminate state to TRUE.

 ****************************************************************/
 void SetConvInTerminateState(hwndClientDDE, hwndServerDDE)
     HWND hwndClientDDE;
     HWND hwndServerDDE;
 {
     struct CONV * pConv;
     int  nConvIndex;

     for (nConvIndex = 0, pConv = Conv;
    nConvIndex < nConvCount;
    nConvIndex++, pConv++)
     {
   if (pConv->hwndClientDDE == hwndClientDDE
       && pConv->hwndServerDDE == hwndServerDDE)
   {
       pConv->bInTerminate = TRUE;
       return;
   }
     }
     return;
 }



 /****************************************************************

     FUNCTION: SetConvItemValue

     PURPOSE:  Find server data item and set value.

 ****************************************************************/
 BOOL SetConvItemValue(hwndClientDDE, szItem, lpszValue)
     HWND hwndClientDDE;
     char * szItem;
     LPSTR  lpszValue;
 {
    struct ITEM * pItem;
    char        * pcValue;

     if (pItem = FindItem(hwndClientDDE, szItem))
     {
         pcValue = pItem->szValue;
         /* copy until <CR> in CF_TEXT data */
         while (*lpszValue != '\r' && *lpszValue)
         {
             *pcValue++ = *lpszValue++;
         }
         *pcValue++ = 0;
   /* Repaint client application window */
   InvalidateRect(hwndMain, NULL, TRUE);
         return (TRUE);
     }
     return (FALSE);
 }



 /****************************************************************

     FUNCTION: SetConvPendingAck

     PURPOSE:  Set the state of acknowledgement for a specified
         conversation.

 ****************************************************************/
 void SetConvPendingAck(hwndClientDDE, ePendingAck)
     HWND hwndClientDDE;
     enum PENDINGACK ePendingAck;
 {
     struct CONV * pConv;

     if (pConv = FindConv(hwndClientDDE))
     {
   pConv->ePendingAck = ePendingAck;
     }
     return;
 }


 CLIDDE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\CLIDDE.C

 /****************************************************************************

     MODULE: CLIDDE.C

     PURPOSE: Processes incoming and outgoing DDE messages


 ****************************************************************************/

 #include "windows.h"

 #include "dde.h"
 #include "clires.h"
 #include "client.h"
 #include <string.h>

 #define DEFAULT_ACK_TIME_OUT_MILLISEC 10000
 static int nAckTimeOut;

 static BOOL   bInInitiate = FALSE;

 BOOL NEAR AwaitingAck(HWND);


 /****************************************************************************

     FUNCTION: AwaitingAck

     PURPOSE:  Inform user if acknowledgement is required before further
               action.

 ****************************************************************************/
 BOOL NEAR AwaitingAck(hwndClientDDE)
     HWND hwndClientDDE;
 {
     if (GetConvPendingAck(hwndClientDDE) == NONE)
     {
         return (FALSE);
     }
     MessageBox(hwndMain,
         "Previous DDE operation must be acknowledged first",
         "Client",
         MB_ICONEXCLAMATION | MB_OK);
     return (TRUE);
 }



 /****************************************************************************

     FUNCTION: ClientAcknowledge

     PURPOSE:  Called when client application receives WM_DDE_ACK message
         or WM_TIMER message (time out on wait for ACK).

 ****************************************************************************/
 void ClientAcknowledge(hwndClientDDE, hwndServerDDE, lParam, bTimeOut)
     HWND hwndClientDDE;
     HWND hwndServerDDE;
     LONG lParam;    /* lParam of WM_DDE_ACK message */
     BOOL bTimeOut;  /* TRUE if NACK is due to time-out */
 {
     enum PENDINGACK ePendingAck;
     char szApplication[APP_MAX_SIZE+1];
     char szTopic[TOPIC_MAX_SIZE+1];
     char szItem[ITEM_MAX_SIZE+1];
     char message[80];

     ePendingAck = GetConvPendingAck(hwndClientDDE);
     SetConvPendingAck(hwndClientDDE, NONE);
     KillTimer(hwndClientDDE, hwndServerDDE);

     if (bInInitiate)
     {
         GlobalGetAtomName(LOWORD(lParam),
             szApplication,
             APP_MAX_SIZE);
         GlobalGetAtomName(HIWORD(lParam),
             szTopic,
             TOPIC_MAX_SIZE);
   if (!AddConv(hwndClientDDE, hwndServerDDE, szApplication, szTopic))
         {
       MessageBox(hwndMain,
     "Maximum conversation count exceeded",
                 "Client",
                 MB_ICONEXCLAMATION | MB_OK);
         }
   /*
   GlobalDeleteAtom(LOWORD(lParam));
         GlobalDeleteAtom(HIWORD(lParam));
   */
         return;
     }
     if ((ePendingAck == ADVISE) && (LOWORD(lParam) & 0x8000))
     {  /* received positive ACK in response to ADVISE */
         GlobalGetAtomName(HIWORD(lParam), szItem, ITEM_MAX_SIZE);
   AddItemToConv(hwndClientDDE, szItem);

   /* Conversation item is established: now get current value */
   /* and update screen            */
   SendRequest(hwndClientDDE, hwndServerDDE, szItem);
   InvalidateRect(hwndMain, NULL, TRUE);
     }
     if ((ePendingAck == UNADVISE) && (LOWORD(lParam) & 0x8000))
     {  /* received positive ACK in response to UNADVISE */
         GlobalGetAtomName(HIWORD(lParam), szItem, ITEM_MAX_SIZE);
   RemoveItemFromConv(hwndClientDDE, szItem);
   InvalidateRect(hwndMain, NULL, TRUE);
     }
     if (!(LOWORD(lParam) & 0x8000))    /* NACK */
     {
         strcpy(message, "DDE ");
         strcat(message, ePendingAck == ADVISE?    "ADVISE "
                       : ePendingAck == UNADVISE?  "UNADVISE "
                       : ePendingAck == POKE?      "POKE "
                       : ePendingAck == REQUEST?   "REQUEST "
           : ePendingAck == EXECUTE?   "EXECUTE "
                       : " ");
         strcat(message, bTimeOut? "acknowledge time out"
                                 : "operation failed");
   MessageBox(hwndMain,
             message,
             "Client",
             MB_ICONEXCLAMATION | MB_OK);
     }
     switch (ePendingAck)
     {
   case ADVISE:
   case UNADVISE:
   case POKE:
   case REQUEST:
       if (HIWORD(lParam))  /* will not be available for time-out */
     GlobalDeleteAtom(HIWORD(lParam));
       break;
   case EXECUTE:
       GlobalFree(HIWORD(lParam)); /* hCommand (execute string) */
       break;
     }
     return;
 }



 /****************************************************************************

     FUNCTION: ClientReceiveData

     PURPOSE:  Called when client application receives WM_DDE_DATA message.

 ****************************************************************************/
 void ClientReceiveData(hwndClientDDE, hwndServerDDE, lParam)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     LONG  lParam;
 {
     DDEDATA FAR * lpDDEData;
     char          szItem[ITEM_MAX_SIZE+1];
     BOOL          bRelease;
     BOOL          bAck;

     if (IsConvInTerminateState(hwndClientDDE, hwndServerDDE))
     { /* Terminate in progress: do not receive data */
         GlobalFree(LOWORD(lParam));
         GlobalDeleteAtom(HIWORD(lParam));
         return;
     }

     if (GetConvPendingAck(hwndClientDDE) == REQUEST)
     {
   SetConvPendingAck(hwndClientDDE, NONE);
   KillTimer(hwndClientDDE, hwndServerDDE);
     }

     if (!(lpDDEData = (DDEDATA FAR *)GlobalLock(LOWORD(lParam)))
         || (lpDDEData->cfFormat != CF_TEXT))
     {
   PostMessage(hwndServerDDE,
             WM_DDE_ACK,
       hwndClientDDE,
             MAKELONG(0, HIWORD(lParam)));  /* Negative ACK */
     }
     bAck = FALSE;
     if (IsInRequestDlg())
     {
   /* Update REQUEST dialog box value */
   RequestSatisfied(lpDDEData->Value);
         bAck = TRUE;
     }
     else
     {
         GlobalGetAtomName(HIWORD(lParam), szItem, ITEM_MAX_SIZE);
   bAck = SetConvItemValue(hwndClientDDE, szItem, lpDDEData->Value);
     }
     if (lpDDEData->fAckReq)
     {
   /* return ACK or NACK */
   PostMessage(hwndServerDDE,
             WM_DDE_ACK,
       hwndClientDDE,
       MAKELONG( (bAck? 0x8000:0), HIWORD(lParam)));
     }
     bRelease = lpDDEData->fRelease;
     GlobalUnlock(LOWORD(lParam));
     if (bRelease)
         GlobalFree(LOWORD(lParam));
     return;
 }


 /****************************************************************************

     FUNCTION: ClientTerminate

     PURPOSE:  Called when client application receives WM_DDE_TERMINATE
         message.

 ****************************************************************************/
 void ClientTerminate(hwndClientDDE, hwndServerDDE)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
 {
     if (!IsConvInTerminateState(hwndClientDDE, hwndServerDDE))
     { /* Server has requested terminate: respond with terminate */
   PostMessage(hwndServerDDE, WM_DDE_TERMINATE, hwndClientDDE, 0L);
     }
     RemoveConv(hwndClientDDE, hwndServerDDE);
     if (!IsHwndClientDDEUsed(hwndClientDDE))
   DestroyWindow(hwndClientDDE);
     InvalidateRect(hwndMain, NULL, TRUE);
     return;
 }



 /****************************************************************************

     FUNCTION: DDEWndProc

     PURPOSE:  Handles all DDE messages received by the client application.

 ****************************************************************************/
 long FAR PASCAL DDEWndProc(hwnd, message, wParam, lParam)
     HWND      hwnd;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     switch (message)
     {
   case WM_DDE_ACK:
       ClientAcknowledge(hwnd,(HWND)wParam, lParam, FALSE);
       return (0L);

   case WM_TIMER:
       /* Negative ACK because of time out */
       ClientAcknowledge(hwnd,(HWND)wParam, 0L, TRUE);
       return (0L);

    case WM_DDE_DATA:
        ClientReceiveData(hwnd,(HWND)wParam, lParam);
        return (0L);

    case WM_DDE_TERMINATE:
         ClientTerminate(hwnd,(HWND)wParam);
         return (0L);

    default:
         return (DefWindowProc(hwnd, message, wParam, lParam));
     }
 }



 /****************************************************************************

     FUNCTION: DoPasteLink

     PURPOSE:  Get conversation information (app/topic/item) from clipboard.
         Initiate conversation, if not already initiated.
         Then, request server to advise the specified item.

         Note, the standard clipboard format registered with the
         name "Link" is as follows:

         <app> <null> <topic> <null> <item> <null> <null>

 ****************************************************************************/
 void DoPasteLink(void)
 {

     HANDLE hData;
     LPSTR  lpData;
     HWND   hwndClientDDE;
     HWND   hwndServerDDE;
     char   szApplication[APP_MAX_SIZE+1];
     char   szTopic[TOPIC_MAX_SIZE+1];
     char   szItem[ITEM_MAX_SIZE+1];
     int    nBufLen;

     if (OpenClipboard(hwndMain))
     {
        if (!(hData = GetClipboardData(cfLink)) ||
     !(lpData = GlobalLock(hData)))
        {
           CloseClipboard();
     return;
        }


        /* Parse clipboard data */
        if ((nBufLen = lstrlen(lpData)) >= APP_MAX_SIZE)
        {
       CloseClipboard();
       GlobalUnlock(hData);
       return;
        }
        lstrcpy(szApplication, lpData);
        lpData += (nBufLen+1); /* skip over null */
        if ((nBufLen = lstrlen(lpData)) >= TOPIC_MAX_SIZE)
        {
       CloseClipboard();
       GlobalUnlock(hData);
       return;
        }
        lstrcpy(szTopic, lpData);
        lpData += (nBufLen+1); /* skip over null */
        if ((nBufLen = lstrlen(lpData)) >= ITEM_MAX_SIZE)
        {
       CloseClipboard();
       GlobalUnlock(hData);
       return;
        }
        lstrcpy(szItem, lpData);

        GlobalUnlock(hData);
        CloseClipboard();

        if (hwndClientDDE = FindConvGivenAppTopic(szApplication, szTopic))
        {   /* app/topic conversation already started */
      if (DoesAdviseAlreadyExist(hwndClientDDE, szItem))
          MessageBox(hwndMain,"Advisory already established",
                    "Client", MB_ICONEXCLAMATION | MB_OK);
            else
          hwndServerDDE = GetHwndServerDDE(hwndClientDDE);
          SendAdvise(hwndClientDDE, hwndServerDDE, szItem);
        }
        else
        {   /* must initiate new conversation first */
      SendInitiate(szApplication, szTopic);
      if (hwndClientDDE = FindConvGivenAppTopic(szApplication, szTopic))
      {
     hwndServerDDE = GetHwndServerDDE(hwndClientDDE);
     SendAdvise(hwndClientDDE, hwndServerDDE, szItem);
      }
        }
     }

     return;
 }



 /****************************************************************************

     FUNCTION: InitAckTimeOut

     PURPOSE:  Get DDE timeout value from win.ini.  Value is in milliseconds.

 ****************************************************************************/
 void InitAckTimeOut(void)
 {

    /* Finds value in win.ini section corresponding to application name */

    nAckTimeOut = GetPrivateProfileInt("Client",
              "DdeTimeOut",
              DEFAULT_ACK_TIME_OUT_MILLISEC,
                                "client.ini");
    return;
 }

 /****************************************************************************

     FUNCTION: SendAdvise

     PURPOSE:  Send advise message to server.


 ****************************************************************************/
 void SendAdvise(hwndClientDDE, hwndServerDDE, szItem)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szItem;
 {
     ATOM            atomItem;
     HANDLE          hOptions;
     DDEADVISE FAR * lpOptions;

     /* don't send another message requiring an ACK until first message */
     /* is acknowledged                   */
     if (AwaitingAck(hwndClientDDE))
         return;

     if (!(hOptions
           = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (LONG)sizeof(DDEADVISE
         return;
     if (!(lpOptions
           = (DDEADVISE FAR *)GlobalLock(hOptions)))
     {
   GlobalFree(hOptions);
         return;
     }
     lpOptions->cfFormat = CF_TEXT;
     lpOptions->fAckReq = TRUE;
     lpOptions->fDeferUpd = FALSE;
     GlobalUnlock(hOptions);
     atomItem = GlobalAddAtom((LPSTR)szItem);
     SetConvPendingAck(hwndClientDDE, ADVISE);
     SetTimer(hwndClientDDE, hwndServerDDE, nAckTimeOut, NULL);
     if (!PostMessage(hwndServerDDE,
             WM_DDE_ADVISE,
       hwndClientDDE,
             MAKELONG(hOptions, atomItem)))
     {
         GlobalDeleteAtom(atomItem);
         GlobalFree(hOptions);
     }
     return;
 }



 /****************************************************************************

     FUNCTION: SendExecute

     PURPOSE:  Send execute string to server.


 ****************************************************************************/
 void SendExecute(hwndClientDDE, hwndServerDDE, szExecuteString)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szExecuteString;
 {
     HANDLE  hExecuteString;
     LPSTR  lpExecuteString;

     /* don't send another message requiring an ACK until first message */
     /* is acknowledged                   */
     if (AwaitingAck(hwndClientDDE))
         return;

     if (!(hExecuteString
           = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
       (DWORD)lstrlen(szExecuteString) + 1)))
         return;
     if (!(lpExecuteString
     = GlobalLock(hExecuteString)))
     {
   GlobalFree(hExecuteString);
         return;
     }
     lstrcpy(lpExecuteString, szExecuteString);
     GlobalUnlock(hExecuteString);
     SetConvPendingAck(hwndClientDDE, EXECUTE);
     SetTimer(hwndClientDDE, hwndServerDDE, nAckTimeOut, NULL);
     if (!PostMessage(hwndServerDDE,
       WM_DDE_EXECUTE,
       hwndClientDDE,
       MAKELONG(0, hExecuteString)))
     {
   GlobalFree(hExecuteString);
     }
     return;
 }



 /****************************************************************************

     FUNCTION: SendInitiate

     PURPOSE:  Sends initiate message to all windows.  By the time this
         function returns, all servers matching the app/topic will
         have acknowledged, and this client applicaiton will have
         temporarily registered the new conversations.   If more
         than one server responded, then this client application
         asks the user which conversation to keep; all other
         conversations will then be terminated.   This function
         returns the handle of the hidden DDE window used to
         initiate the conversation with server(s).

 ****************************************************************************/
 HWND SendInitiate(szApplication, szTopic)
     char * szApplication;
     char * szTopic;
 {
     HWND  hwndClientDDE;
     ATOM  atomApplication;
     ATOM  atomTopic;

     if (!(hwndClientDDE = CreateWindow(
       "ClientDDEWndClass",
       "ClientDDE",
       WS_CHILD,  /* not visible */
       0, 0, 0, 0, /* no position or dimensions */
       hwndMain,  /* parent */
       NULL,  /* no menu */
       hInst,
       NULL)))
     {
   return (NULL);
     }

     atomApplication
         = *szApplication == 0 ? NULL : GlobalAddAtom((LPSTR)szApplication);
     atomTopic
         = *szTopic == 0 ? NULL : GlobalAddAtom((LPSTR)szTopic);

     /* flag bIniInitiate is queried when client processes the server's ACK */
     bInInitiate = TRUE;
     SendMessage(-1,
         WM_DDE_INITIATE,
   hwndClientDDE,
         MAKELONG(atomApplication, atomTopic));
     bInInitiate = FALSE;
     if (atomApplication != NULL)
         GlobalDeleteAtom(atomApplication);
     if (atomTopic != NULL)
         GlobalDeleteAtom(atomTopic);
     return (hwndClientDDE);
 }

 /****************************************************************************

     FUNCTION: SendPoke

     PURPOSE:  Send poke message to server.


 ****************************************************************************/
 void SendPoke(hwndClientDDE, hwndServerDDE, szItem, szValue)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szItem;
     char * szValue;
 {
     ATOM        atomItem;
     HANDLE      hPokeData;
     DDEPOKE FAR * lpPokeData;

     /* don't send another message requiring an ACK until first message */
     /* is acknowledged                   */
     if (AwaitingAck(hwndClientDDE))
         return;

     /* Allocate size of DDE data header, plus the data:  a string   */
     /* terminated by <CR> <LF> <NULL>.  The <NULL> is counted by    */
     /* by DDEPOKE.Value[1].                                         */

     if (!(hPokeData
           = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
                         (LONG)sizeof(DDEPOKE) + lstrlen(szValue) + 2)))
         return;
     if (!(lpPokeData
           = (DDEPOKE FAR*)GlobalLock(hPokeData)))
     {
   GlobalFree(hPokeData);
         return;
     }
     lpPokeData->fRelease = TRUE;
     lpPokeData->cfFormat = CF_TEXT;
     lstrcpy((LPSTR)lpPokeData->Value, (LPSTR)szValue);
     /* each line of CF_TEXT data is terminated by CR/LF */
     lstrcat((LPSTR)lpPokeData->Value, (LPSTR)"\r\n");
     GlobalUnlock(hPokeData);
     atomItem = GlobalAddAtom((LPSTR)szItem);
     SetConvPendingAck(hwndClientDDE, POKE);
     SetTimer(hwndClientDDE, hwndServerDDE, nAckTimeOut, NULL);
     if (!PostMessage(hwndServerDDE,
             WM_DDE_POKE,
       hwndClientDDE,
             MAKELONG(hPokeData, atomItem)))
     {
         GlobalDeleteAtom(atomItem);
         GlobalFree(hPokeData);
     }
     return;
 }



 /****************************************************************************

     FUNCTION: SendRequest

     PURPOSE:  Send request message to server.


 ****************************************************************************/
 void SendRequest(hwndClientDDE, hwndServerDDE, szItem)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szItem;
 {
     ATOM  atomItem;

     /* don't send another message requiring an ACK until first message */
     /* is acknowledged                   */
     if (AwaitingAck(hwndClientDDE))
         return;

     atomItem = GlobalAddAtom((LPSTR)szItem);
     SetConvPendingAck(hwndClientDDE, REQUEST);
     SetTimer(hwndClientDDE, hwndServerDDE, nAckTimeOut, NULL);
     if (!PostMessage(hwndServerDDE,
             WM_DDE_REQUEST,
       hwndClientDDE,
             MAKELONG(CF_TEXT,atomItem)))
     {
         GlobalDeleteAtom(atomItem);
     }
     return;
 }


 /****************************************************************************

     FUNCTION: SendTerminate

     PURPOSE:  Send terminate message to server.

 ****************************************************************************/
 void SendTerminate(hwndClientDDE, hwndServerDDE)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
 {
     MSG msg;
     LONG lTimeOut;

     SetConvInTerminateState(hwndClientDDE, hwndServerDDE);
     PostMessage(hwndServerDDE, WM_DDE_TERMINATE, hwndClientDDE, 0L);
     return;
 }




 /****************************************************************************

     FUNCTION: SendUnadvise

     PURPOSE:  Send unadvise message to server.


 ****************************************************************************/
 void SendUnadvise(hwndClientDDE, hwndServerDDE, szItem)
     HWND  hwndClientDDE;
     HWND  hwndServerDDE;
     char * szItem;
 {
     ATOM  atomItem;

     /* don't send another message requiring an ACK until first message */
     /* is acknowledged                   */
     if (AwaitingAck(hwndClientDDE))
         return;

     atomItem = GlobalAddAtom((LPSTR)szItem);
     SetConvPendingAck(hwndClientDDE, UNADVISE);
     SetTimer(hwndClientDDE, hwndServerDDE, nAckTimeOut, NULL);
     if (!PostMessage(hwndServerDDE,
             WM_DDE_UNADVISE,
       hwndClientDDE,
             MAKELONG(0,atomItem)))
     {
         GlobalDeleteAtom(atomItem);
     }
     return;
 }


 /****************************************************************************

     FUNCTION: TerminateConversations

     PURPOSE:  Processes WM_DESTROY message, terminates all conversations.

 ****************************************************************************/
 void TerminateConversations(void)
 {
    HWND  hwndClientDDE;
    HWND  hwndServerDDE;
    LONG  lTimeOut;
    MSG   msg;


    /* Terminate each active conversation */
    hwndClientDDE = NULL;
    while (hwndClientDDE = GetNextConv(hwndClientDDE))
    {
   hwndServerDDE = GetHwndServerDDE(hwndClientDDE);
   if (IsWindow(hwndServerDDE)) /* if server window still alive */
       SendTerminate(hwndClientDDE, hwndServerDDE);
    }

    /* Wait for all conversations to terminate or for time out */
    lTimeOut = GetTickCount() + (LONG)nAckTimeOut;
    while (PeekMessage(&msg, NULL, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
    {
          DispatchMessage (&msg);
    if (msg.message == WM_DDE_TERMINATE)
    {
        if (!AtLeastOneConvActive())
      break;
    }
          if (GetTickCount() > lTimeOut)
              break;
    }

    return;
 }


 CLIENT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\CLIENT.C

 /****************************************************************************

     PROGRAM: CLIENT

     PURPOSE: Illustrates client side of DDE conversation

     MODULES:

         CLIENT.C   Window and dialog procedures.
   CLIDATA.C  Maintains conversation data.
         CLIDDE.C   Processes incoming and outgoing DDE messages.

 ****************************************************************************/

 #include "windows.h"

 #include "dde.h"
 #include "clires.h"
 #include "client.h"
 #include <string.h>
 #include <stdlib.h>

 static int    nInstCount;
 static HWND   hwndRequestDlg;

 static BOOL   bInInitiate = FALSE;
 static BOOL   bInRequestDlg = FALSE;
 static BOOL   bTerminating = FALSE;

 static char  szSelectedApplication[APP_MAX_SIZE+1];
 static char  szSelectedTopic[TOPIC_MAX_SIZE+1];
 static char  szSelectedItem[ITEM_MAX_SIZE+1];
 static char  szSelectedValue[VALUE_MAX_SIZE+1];
 static HWND  hwndSelectedClientDDE;
 static int   cfSelectedFormat;

 long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);
 BOOL            InitApplication(HANDLE);
 void            InitAddedInstance(HANDLE, HANDLE);
 BOOL            InitInstance(HANDLE, int);
 int  NEAR  DoDialog(char *, FARPROC);
 BOOL FAR PASCAL AboutDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL AdviseDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL ClearDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL ExecuteDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL InitiateDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL PokeDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL RequestDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL TerminateDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL UnadviseDlgProc(HWND, unsigned, WORD, LONG);
 void    AddConversationsToBox(HWND, unsigned);
 void NEAR  GetSelectedConversation(HWND, unsigned, unsigned);


 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: Calls initialization functions and processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
     {
         if (!InitApplication(hInstance))
          return (FALSE);
     }
     else
     {
         InitAddedInstance(hInstance, hPrevInstance);
     }

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL))
     {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window classes

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     nInstCount = 1;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "ClientMenu";
     wc.lpszClassName = "ClientWClass";

     if (!RegisterClass(&wc))
   return (FALSE);

     wc.style = NULL;
     wc.lpfnWndProc = DDEWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = NULL;
     wc.hCursor = NULL;
     wc.hbrBackground = NULL;
     wc.lpszMenuName =  NULL;
     wc.lpszClassName = "ClientDDEWndClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION: InitAddedInstance

     PURPOSE:  Increment instance counter.

 ****************************************************************************/
 void InitAddedInstance(hInstance, hPrevInstance)
     HANDLE  hInstance;
     HANDLE  hPrevInstance;
 {
     GetInstanceData(hPrevInstance, (NPSTR)&nInstCount, sizeof(int));
     nInstCount++;
     return;
 }



 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HDC         hDC;
     TEXTMETRIC  tm;

     hInst = hInstance;

     hwndMain = CreateWindow(
         "ClientWClass",
         "Client",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwndMain)
         return (FALSE);

     InitDataTextMetrics();
     InitAckTimeOut();      /* in module CLIDDE */

     MoveWindow(hwndMain,
         xDelta*(5+nInstCount),
         ((nInstCount-1)&1)*nVertRes/2 + yDelta*nInstCount,
         xDelta*30,
         yDelta*12,
         FALSE);

     if (!(cfLink = RegisterClipboardFormat("Link")))
   return (FALSE);

     ShowWindow(hwndMain, nCmdShow);
     UpdateWindow(hwndMain);

     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for client application.
         DDE messages are handled by DDEWndProc in CLIDDE.C.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     char  szApplication[APP_MAX_SIZE+1];
     char  szTopic[TOPIC_MAX_SIZE+1];

     switch (message)
     {
         case WM_PAINT:
       PaintConvData(hwnd);
             return (0L);

         case WM_INITMENU:
             if (wParam == GetMenu(hwnd))
             {
     if (IsClipboardFormatAvailable(cfLink))
         EnableMenuItem(wParam, IDM_PASTELINK, MF_ENABLED);
     else
         EnableMenuItem(wParam, IDM_PASTELINK, MF_GRAYED);
             }
             return (0L);

         case WM_COMMAND:
             switch (wParam)
             {
     case IDM_INITIATE:
                     /* If we are in the process of terminating, no new
                        conversations are allowed */
                     if (!bTerminating)
                     {
       DoDialog("Initiate", InitiateDlgProc);
                     }
                     return 0L;

                 case IDM_TERMINATE:
         DoDialog("Terminate", TerminateDlgProc);
                     return 0L;

                 case IDM_ADVISE:
         DoDialog("Advise", AdviseDlgProc);
                     return 0L;

                 case IDM_UNADVISE:
         DoDialog("Unadvise", UnadviseDlgProc);
                     return 0L;

                 case IDM_REQUEST:
         DoDialog("Request", RequestDlgProc);
                     return 0L;

                 case IDM_POKE:
         DoDialog("Poke", PokeDlgProc);
                     return 0L;

                 case IDM_PASTELINK:
         DoPasteLink();
                     return 0L;

                 case IDM_CLEAR:
         DoDialog("Clear", ClearDlgProc);
                     return 0L;

     case IDM_EXECUTE:
         DoDialog("Execute", ExecuteDlgProc);
         return 0L;

     case IDM_ABOUT:
         DoDialog("About", AboutDlgProc);
         break;

                 default:
                     return (DefWindowProc(hwnd, message, wParam, lParam));
             }
             break;

         case WM_DESTROY:
             /* Terminate all DDE conversations before destroying
                client window */
       bTerminating = TRUE;
       TerminateConversations();
             PostQuitMessage(0);
             break;

   default:
       return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (0L);
 }


 /****************************************************************************

     FUNCTION: DoDialog

     PURPOSE:  Creates dialog given dialog i.d.

 ****************************************************************************/
 int NEAR DoDialog(szDialog, lpfnDlgProc)
     char   * szDialog;
     FARPROC  lpfnDlgProc;
 {
     int      nReturn;

     lpfnDlgProc = MakeProcInstance(lpfnDlgProc, hInst);
     nReturn = DialogBox(hInst,
   szDialog,
   hwndMain,
         lpfnDlgProc);
     FreeProcInstance(lpfnDlgProc);
     return  (nReturn);
 }



 /****************************************************************************

     FUNCTION: AboutDlgProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

 ****************************************************************************/

 BOOL FAR PASCAL AboutDlgProc(hDlg, message, wParam, lParam)
     HWND hDlg;
     unsigned message;
     WORD wParam;
     LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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



 /****************************************************************************

     FUNCTION: AdviseDlgProc

     PURPOSE:  Processes messages for the Advise dialog.

 ****************************************************************************/
 BOOL FAR PASCAL AdviseDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hwndServerDDE;

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
                         IDC_ITEM,
                         (LPSTR)szSelectedItem,
                         ITEM_MAX_SIZE);
         if (DoesAdviseAlreadyExist(hwndSelectedClientDDE,
                                                szSelectedItem))
                         MessageBox(hdlg, "Advisory already established",
                             "Client", MB_ICONEXCLAMATION | MB_OK);
                     else
       hwndServerDDE
           = GetHwndServerDDE(hwndSelectedClientDDE);
       SendAdvise(hwndSelectedClientDDE,
           hwndServerDDE,
           szSelectedItem);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
         return (FALSE);
             }

         default:
             return (FALSE);
     }
     return (FALSE);
 }



 /****************************************************************************

     FUNCTION: ClearDlgProc

     PURPOSE:  Processes messages for the Clear dialog.

 ****************************************************************************/
 BOOL FAR PASCAL ClearDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hwndServerDDE;
     HWND  hctlItemBox;
     int   nIndex;

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
                         IDC_ITEM,
                         (LPSTR)szSelectedItem,
                         ITEM_MAX_SIZE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendUnadvise(hwndSelectedClientDDE,
       hwndServerDDE,
       szSelectedItem);
                     EndDialog(hdlg, TRUE);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
                     return (TRUE);
             }
         default:
             return (FALSE);
     }
     return (FALSE);
 }



 /****************************************************************************

     FUNCTION: ExecuteDlgProc

     PURPOSE:  Processes messages for the Execute dialog.

 ****************************************************************************/
 BOOL FAR PASCAL ExecuteDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hwndServerDDE;
     char  szExecuteString[EXECUTE_STRING_MAX_SIZE+1];

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
       IDC_EXECUTE_STRING,
       (LPSTR)szExecuteString,
       EXECUTE_STRING_MAX_SIZE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendExecute(hwndSelectedClientDDE,
       hwndServerDDE,
       szExecuteString);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
         return (TRUE);
             }

         default:
             return (FALSE);
     }
     return (FALSE);
 }




 /****************************************************************************

     FUNCTION: InitiateDlgProc

     PURPOSE:  Processes messages for the Initiate dialog.

 ****************************************************************************/
 BOOL FAR PASCAL InitiateDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND      hwndClientDDE;

     switch (message)
     {
         case WM_INITDIALOG:
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
                     GetDlgItemText(hdlg,
                         IDC_APPLICATION,
                         (LPSTR)szSelectedApplication,
                         APP_MAX_SIZE);
                     GetDlgItemText(hdlg,
                         IDC_TOPIC,
                         (LPSTR)szSelectedTopic,
                         TOPIC_MAX_SIZE);
                     EndDialog(hdlg, TRUE);
         if (hwndClientDDE
       = SendInitiate(szSelectedApplication, szSelectedTopic))
         {
       LetUserPickConversation(hwndClientDDE);
       InvalidateRect(hwndMain, NULL, TRUE);
         }
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
                     return (TRUE);
             }
         default:
             return (FALSE);
     }
     return (FALSE);
 }




 /****************************************************************************

     FUNCTION: PokeDlgProc

     PURPOSE:  Processes messages for the Poke dialog.

 ****************************************************************************/
 BOOL FAR PASCAL PokeDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hwndServerDDE;

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
                         IDC_ITEM,
                         (LPSTR)szSelectedItem,
                         ITEM_MAX_SIZE);
                     GetDlgItemText(hdlg,
                         IDC_VALUE,
                         (LPSTR)szSelectedValue,
                         VALUE_MAX_SIZE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendPoke(hwndSelectedClientDDE,
       hwndServerDDE,
                         szSelectedItem,
                         szSelectedValue);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
         return (TRUE);
             }

         default:
             return (FALSE);
     }
     return (FALSE);
 }


 /****************************************************************************

     FUNCTION: RequestDlgProc

     PURPOSE:  Processes messages for the Request dialog.

 ****************************************************************************/
 BOOL FAR PASCAL RequestDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hwndServerDDE;

     switch (message)
     {
         case WM_INITDIALOG:
             hwndRequestDlg = hdlg;
             bInRequestDlg = TRUE;
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
                         IDC_ITEM,
                         (LPSTR)szSelectedItem,
                         ITEM_MAX_SIZE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendRequest(hwndSelectedClientDDE,
       hwndServerDDE,
       szSelectedItem);
         return (TRUE);

                 case IDC_CANCEL:
                     bInRequestDlg = FALSE;
                     EndDialog(hdlg, FALSE);
                     return (TRUE);
             }
             break;

         case WM_DESTROY:
             bInRequestDlg = FALSE;
             return (FALSE);

         default:
             return (FALSE);
     }
     return (FALSE);
 }



 /****************************************************************************

     FUNCTION: TerminateDlgProc

     PURPOSE:  Processes messages for the Terminate dialog.

 ****************************************************************************/
 BOOL FAR PASCAL TerminateDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND hwndServerDDE;

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, LB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, LB_GETCURSEL, LB_GETTEXT);
                     EndDialog(hdlg, TRUE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendTerminate(hwndSelectedClientDDE, hwndServerDDE);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
         return (TRUE);
             }
         default:
             return (FALSE);
     }
     return (FALSE);
 }




 /****************************************************************************

     FUNCTION: UnadviseDlgProc

     PURPOSE:  Processes messages for the Unadvise dialog.

 ****************************************************************************/
 BOOL FAR PASCAL UnadviseDlgProc(hdlg, message, wParam, lParam)
     HWND      hdlg;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     HWND  hctlItemBox;
     int   nIndex;
     HWND  hwndServerDDE;

     switch (message)
     {
         case WM_INITDIALOG:
       AddConversationsToBox(hdlg, CB_ADDSTRING);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
             {
                 case IDC_OK:
         GetSelectedConversation(hdlg, CB_GETCURSEL, CB_GETLBTEXT);
                     GetDlgItemText(hdlg,
                         IDC_ITEM,
                         (LPSTR)szSelectedItem,
                         ITEM_MAX_SIZE);
         hwndServerDDE = GetHwndServerDDE(hwndSelectedClientDDE);
         SendUnadvise(hwndSelectedClientDDE,
       hwndServerDDE,
                         szSelectedItem);
         return (TRUE);

                 case IDC_CANCEL:
                     EndDialog(hdlg, FALSE);
                     return (TRUE);
             }
         default:
             return (FALSE);
     }
     return (FALSE);
 }



 /****************************************************************

     FUNCTION: AddConversationsToBox

     PURPOSE:  Add server, app, topic info to client list box


 ****************************************************************/
 void AddConversationsToBox(hdlg, nAddMessage)
     HWND      hdlg;
     unsigned  nAddMessage;  /* LB_ADDSTRING or CB_ADDSTRING */
 {
     HWND  hwndClientDDE;
     HWND  hctlServerList;
     char  szConvInfo[CONVINFO_MAX_SIZE+1];
     char  szApp[APP_MAX_SIZE+1];
     char  szTopic[TOPIC_MAX_SIZE+1];

     hctlServerList = GetDlgItem(hdlg, IDC_CONVBOX);
     SendMessage(hctlServerList,
         nAddMessage == LB_ADDSTRING ? LB_RESETCONTENT : CB_RESETCONTENT,
         0,
         0L);
     hwndClientDDE = NULL;
     while (1)
     {
   if (!(hwndClientDDE = GetNextConv(hwndClientDDE)))
       break;
   itoa((int)hwndClientDDE, szConvInfo, 16);
   strupr(szConvInfo);
   strcat(szConvInfo,"->");
   itoa((int)GetHwndServerDDE(hwndClientDDE),
       szConvInfo+strlen(szConvInfo),
       16);
   strcat(szConvInfo," ");
   GetAppAndTopic(hwndClientDDE, szApp, szTopic);
   strcat(szConvInfo, szApp);
   strcat(szConvInfo, " | ");
   strcat(szConvInfo, szTopic);

         SendMessage(hctlServerList,
             nAddMessage,
             0,
       (LONG)(LPSTR)szConvInfo);
     }
     if (nAddMessage == CB_ADDSTRING)
     {
   SendMessage(hctlServerList, CB_SETCURSEL, 0, 0L);
     }
     return;
 }


 /*********************************************************************

     FUNCTION: IsInRequestDlg

     PURPOSE:  Returns whether the user is in the Request dialog or not.

 *********************************************************************/
 BOOL IsInRequestDlg()
 {
     return (bInRequestDlg);
 }



 /*********************************************************************

     FUNCTION: GetSelectedConversation

     PURPOSE:  Gets the user's selection from the conversation list
         box, and returns result in hwndSelectedClientDDE.

 *********************************************************************/
 void NEAR GetSelectedConversation(hdlg, nCurSelMessage, nGetTextMessage)
     HWND      hdlg;
     unsigned  nCurSelMessage;
     unsigned  nGetTextMessage;
 {
     HWND hctlConvBox;
     int  nIndex;
     char szConvInfo[CONVINFO_MAX_SIZE+1];
     char * pcBlank;


     hctlConvBox = GetDlgItem(hdlg, IDC_CONVBOX);
     if ((nIndex = SendMessage(hctlConvBox, nCurSelMessage, 0, 0L))
         != LB_ERR)
     {
   szConvInfo[0] = 0;
   SendMessage(hctlConvBox,
             nGetTextMessage,
             nIndex,
       (LONG)(LPSTR)szConvInfo);
   /* find '-' in 'hwnd->hwnd' list box entry */
   if (!(pcBlank = strchr(szConvInfo, '-')))
             return;
         *pcBlank = 0;  /* terminate hwnd numeric value */
   hwndSelectedClientDDE = HexToInt(szConvInfo);
      }
      return;
 }



 /****************************************************************

     FUNCTION: InitDataTextMetrics

     PURPOSE:  Get font information

 ****************************************************************/
 void InitDataTextMetrics()
 {
     HDC hDC;
     TEXTMETRIC tm;

     hDC = GetDC(hwndMain);
     GetTextMetrics(hDC, (LPTEXTMETRIC)&tm);
     nHorzRes = GetDeviceCaps(hDC, HORZRES);
     nVertRes = GetDeviceCaps(hDC, VERTRES);
     ReleaseDC(hwndMain, hDC);
     yDelta = tm.tmHeight + tm.tmExternalLeading;
     xDelta = tm.tmAveCharWidth;
     return;
 }


 /*********************************************************************

     FUNCTION: RequestSatisfied

     PURPOSE:  Updates Request dialog box with value requested from
         server.

 *********************************************************************/
 void RequestSatisfied(lpszValue)
     LPSTR lpszValue;
 {
     HWND hctlValue;

     hctlValue = GetDlgItem(hwndRequestDlg, IDC_VALUE);
     SetWindowText(hctlValue, lpszValue);
     return;
 }


 /*********************************************************************

     FUNCTION: SetSelectedValue

     PURPOSE:  Set specified value.

 *********************************************************************/
 void SetSelectedValue(lpszSelectedValue)
     LPSTR lpszSelectedValue;
 {
     lstrcpy((LPSTR)szSelectedValue, lpszSelectedValue);
     return;
 }


 CLIPTEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\CLIPTEXT\CLIPTEXT.C

 /****************************************************************************

     PROGRAM: Cliptext.c

     PURPOSE: Demonstrates copying text to and from the clipboard

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box
         OutOfMemory() - displays warning message

 ****************************************************************************/

 #include "windows.h"
 #include "cliptext.h"

 HANDLE hInst;
 HANDLE hAccTable;
 HWND   hwnd;

 HANDLE hText = NULL;

 char szInitialClientAreaText[] =
     "This program demonstrates the use of the Edit menu to copy and "
     "paste text to and from the clipboard.  Try using the Copy command "
     "to move this text to the clipboard, and the Paste command to replace "
     "this text with data from another application.  \r\n\r\n"
     "You might want to try running Notepad and Clipbrd alongside this "
     "application so that you can watch the data exchanges take place.  ";

 HANDLE hData, hClipData;                            /* handles to clip data
 LPSTR lpData, lpClipData;                           /* pointers to clip data

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;
     LPSTR lpszText;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "CliptextMenu";
     wc.lpszClassName = "CliptextWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     LPSTR           lpszText;

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "ClipTextAcc");

     if (!(hText
           = GlobalAlloc(GMEM_MOVEABLE,(DWORD)sizeof(szInitialClientAreaText))
         OutOfMemory();
         return (FALSE);
     }

     if (!(lpszText = GlobalLock(hText))) {
         OutOfMemory();
         return (FALSE);
     }

     lstrcpy(lpszText, szInitialClientAreaText);
     GlobalUnlock(hText);

     hwnd = CreateWindow(
         "CliptextWClass",
         "Cliptext Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

         WM_COMMAND    - message from menu
         WM_INITMENU   - initialize menu
   WM_PAINT      - update window
         WM_DESTROY    - destroy window

     COMMENTS:

         WM_INITMENU - when this message is received, the application checks
         to see if there is any text data in the clipboard, and enables or
         disables the Paste menu item accordingly.

         Seclecting the Copy menu item will send the text "Hello Windows" to
         the clipboard.

         Seclecting the Paste menu item will copy whatever text is in the
         clipboard to the application window.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;
     HDC hDC;
     HMENU hMenu;
     PAINTSTRUCT ps;
     RECT rectClient;
     LPSTR lpszText;

     switch (message) {

         case WM_INITMENU:
             if (wParam == GetMenu(hWnd)) {
                 if (OpenClipboard(hWnd)) {
                     if (IsClipboardFormatAvailable(CF_TEXT)
                         || IsClipboardFormatAvailable(CF_OEMTEXT))
                         EnableMenuItem(wParam, IDM_PASTE, MF_ENABLED);
                     else
                         EnableMenuItem(wParam, IDM_PASTE, MF_GRAYED);
                     CloseClipboard();
                     return (TRUE);
                 }
                 else                           /* Clipboard is not available
                     return (FALSE);

             }
             return (TRUE);

         case WM_COMMAND:
             switch(wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 /* file menu commands */

                 case IDM_NEW:
                 case IDM_OPEN:
                 case IDM_SAVE:
                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus ()
                         , "Command not implemented."
                         , "ClipText Sample Application"
                         , MB_ICONASTERISK | MB_OK
                     );
                     break;

                 case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus ()
                         , "Command not implemented."
                         , "ClipText Sample Application"
                         , MB_ICONASTERISK | MB_OK
                     );
                     break;

                 case IDM_CUT:
                 case IDM_COPY:

                     if (hText != NULL) {

                         /* Allocate memory and copy the string to it */

                         if (!(hData
                              = GlobalAlloc(GMEM_MOVEABLE, GlobalSize (hText))
                             OutOfMemory();
                             return (TRUE);
                         }
                         if (!(lpData = GlobalLock(hData))) {
                             OutOfMemory();
                             return (TRUE);
                         }
                         if (!(lpszText = GlobalLock (hText))) {
                             OutOfMemory();
                             return (TRUE);
                         }
                         lstrcpy(lpData, lpszText);
                         GlobalUnlock(hData);
                         GlobalUnlock (hText);

                         /* Clear the current contents of the clipboard, and s
                          * the data handle to the new string.
                          */

                         if (OpenClipboard(hWnd)) {
                             EmptyClipboard();
                             SetClipboardData(CF_TEXT, hData);
                             CloseClipboard();
                         }
                         hData = NULL;

                         if (wParam == IDM_CUT) {
                             GlobalFree (hText);
                             hText = NULL;
                             EnableMenuItem(GetMenu (hWnd), IDM_CUT, MF_GRAYED
                             EnableMenuItem(GetMenu(hWnd), IDM_COPY, MF_GRAYED
                             InvalidateRect (hWnd, NULL, TRUE);
                             UpdateWindow (hWnd);
                         }
                     }

                     return (TRUE);

                 case IDM_PASTE:
                     if (OpenClipboard(hWnd)) {

                         /* get text from the clipboard */

                         if (!(hClipData = GetClipboardData(CF_TEXT))) {
                             CloseClipboard();
                             break;
                         }
                         if (hText != NULL) {
                             GlobalFree(hText);
                         }
                         if (!(hText = GlobalAlloc(GMEM_MOVEABLE
                                                     , GlobalSize(hClipData)))
                             OutOfMemory();
                             CloseClipboard();
                             break;
                         }
                         if (!(lpClipData = GlobalLock(hClipData))) {
                             OutOfMemory();
                             CloseClipboard();
                             break;
                         }
                         if (!(lpszText = GlobalLock(hText))) {
                             OutOfMemory();
                             CloseClipboard();
                             break;
                         }
                         lstrcpy(lpszText, lpClipData);
                         GlobalUnlock(hClipData);
                         CloseClipboard();
                         GlobalUnlock(hText);
                         EnableMenuItem(GetMenu(hWnd), IDM_CUT, MF_ENABLED);
                         EnableMenuItem(GetMenu(hWnd), IDM_COPY, MF_ENABLED);

                         /* copy text to the application window */

                         InvalidateRect(hWnd, NULL, TRUE);
                         UpdateWindow(hWnd);
                         return (TRUE);
                     }
                     else
                         return (FALSE);
             }
             break;

   case WM_SIZE:
       InvalidateRect(hWnd, NULL, TRUE);
       break;

   case WM_PAINT:
             hDC = BeginPaint (hWnd, &ps);
             if (hText != NULL) {
                 if (!(lpszText = GlobalLock (hText))) {
                     OutOfMemory();
                 } else {
         GetClientRect (hWnd, &rectClient);
                     DrawText (hDC, lpszText, -1, &rectClient
                                 , DT_EXTERNALLEADING | DT_NOPREFIX | DT_WORDB
                     GlobalUnlock (hText);
                 }
             }
       EndPaint (hWnd, &ps);
             break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 /****************************************************************************

     FUNCTION: OutOfMemory(void)

     PURPOSE:  Displays warning message

 ****************************************************************************/
 void OutOfMemory(void)
 {
     MessageBox(
         GetFocus(),
         "Out of Memory",
         NULL,
         MB_ICONHAND | MB_SYSTEMMODAL);
     return;
 }


 CLOCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\CLOCK\CLOCK.C

 /***************************************************************************
  *                                                                         *
  *  PROGRAM   : Clock.c                                                    *
  *                                                                         *
  *  PURPOSE   : To give a demonstration on the use of a timer in a windows *
  *              application.                                               *
  *                                                                         *
  *  MACROS    : HourHandPos  - Computes the hour hand position based on    *
  *                             both the hour and minute values.            *
  *                                                                         *
  *              VertEquiv    - Computes the raster line equivalent to the  *
  *                             given pixel value.                          *
  *                                                                         *
  *              HorzEquiv    - Computes the pixel equivalent to the given  *
  *                             raster line value.                          *
  *                                                                         *
  *  FUNCTIONS : About        - Dialog function for the About Dialog.       *
  *                                                                         *
  *              ClockWndProc - Window function for the application.        *
  *                                                                         *
  *              CreateTools  - Creates brushes and pens to coincide with   *
  *                             the current system colors.                  *
  *                                                                         *
  *              DeleteTools  - Destroys the brushes and pens created by    *
  *                             CreateTools.                                *
  *                                                                         *
  *              ClockCreate  - Performs the necessary initialization for   *
  *                             drawing the clock correctly and gets the    *
  *                             initial time to be displayed by the clock.  *
  *                                                                         *
  *              ClockSize    - Resize the clock to the largest possible    *
  *                             circle that will fit in the client area.    *
  *                                                                         *
  *              ClockTimer   - Update the clock to reflect the most recent *
  *                             time.                                       *
  *                                                                         *
  *              ClockPaint   - Paint the clock to display the most recent  *
  *                             time.                                       *
  *                                                                         *
  *              DrawFace     - Draws the clock face.                       *
  *                                                                         *
  *              DrawHand     - Draws a thin hand with the specified brush  *
  *                             in the specified hand position.             *
  *                                                                         *
  *              DrawFatHand  - Draws a fat hand with the specified brush   *
  *                             in the specified hand position.             *
  *                                                                         *
  *              CircleClock  - Resizes clock rectangle to keep clock       *
  *                             circular.                                   *
  *                                                                         *
  *              WinMain      - Calls the initialization function, creates  *
  *                             the main application window, and enters the *
  *                             message loop.                               *
  *                                                                         *
  *              ClockInit    - Registers the application window class and  *
  *                             initializes the circle values for the clock *
  *                             face.                                       *
  *                                                                         *
  ***************************************************************************/

 #include "windows.h"
 #include "clock.h"

 /* Structure for holding time (in hours, minutes, and seconds) */
 typedef struct
 {
   int hour;
   int minute;
   int second;
 } TIME;

 extern void GetTime(TIME *); /* asm function to get current time */

 TIME oTime;             /* the time currently displayed on the clock

 HBRUSH hbrForegnd;      /* foreground brush -- system window text color
 HBRUSH hbrBackgnd;      /* background brush -- system window backbround color
 HPEN   hpenForegnd;     /* foreground pen   -- system window text color
 HPEN   hpenBackgnd;     /* background pen   -- system window background color

 HANDLE hInst;           /* instance of the CLOCK program being executed
 BOOL   bFirst = TRUE;   /* TRUE if this is the 1st instance; FALSE otherwise

 HANDLE    hCirTab;      /* Circle table for the circular clock face positions
 POINT FAR *lpCirTab;    /* Pointer to the circle table

 int   TimerID = 1;      /* number used for timer-id
 char  szBuffer[BUFLEN]; /* buffer for stringtable data
 RECT  ClockRect;        /* rectangle that EXACTLY bounds the clock face
 long  ClockRadius;      /* clock face radius
 POINT ClockCenter;      /* clock face center
 BOOL  bIconic = FALSE;  /* TRUE if clock is currently iconic; FALSE otherwise

 int   HorzRes;          /* width of the display (in pixels)
 int   VertRes;          /* height of the display (in raster lines)
 long  AspectH;          /* number of pixels per decimeter on the display
 long  AspectV;          /* number of raster lines per decimeter on the displa


 /***************************************************************************
  *                                                                         *
  *  MACRO    : HourHandPos (TIME)                                          *
  *                                                                         *
  *  PURPOSE  : Computes the hour hand position based on both the hour and  *
  *             minute values in the given time record.                     *
  *                                                                         *
  ***************************************************************************/

 #define HourHandPos(time)  (time.hour * 5) + (time.minute /12)


 /***************************************************************************
  *                                                                         *
  *  MACRO    : VertEquiv (int)                                             *
  *                                                                         *
  *  PURPOSE  : Computes the raster line (vertical) equivalent to the given *
  *             pixel (horizontal) value.                                   *
  *                                                                         *
  ***************************************************************************/

 #define VertEquiv(lengthH) ((lengthH * AspectV) / AspectH)


 /***************************************************************************
  *                                                                         *
  *  MACRO    : HorzEquiv (int)                                             *
  *                                                                         *
  *  PURPOSE  : Computes the pixel (horizontal) equivalent to the given     *
  *             raster line (vertical) value.                               *
  *                                                                         *
  ***************************************************************************/

 #define HorzEquiv(lengthV) ((lengthV * AspectH) / AspectV)


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : About (HWND, unsigned, WORD, LONG)                          *
  *                                                                         *
  *  PURPOSE  : Dialog function for the "About..." menu item dialog.        *
  *                                                                         *
  ***************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
   HWND     hDlg;
   unsigned message;
   WORD     wParam;
   LONG     lParam;
 {
   switch (message)
   {
     case WM_COMMAND:
       EndDialog(hDlg, TRUE);
       /* fall through */

     case WM_INITDIALOG:
       return(TRUE);

     default:
       return(FALSE);
   }
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockWndProc (HWND, unsigned, WORD, LONG)                   *
  *                                                                         *
  *  PURPOSE  : Window function for the application.                        *
  *                                                                         *
  ***************************************************************************/

 long FAR PASCAL ClockWndProc(hWnd, message, wParam, lParam)
   HWND     hWnd;
   unsigned message;
   WORD     wParam;
   LONG     lParam;
 {
   switch (message)
   {
     case WM_SYSCOMMAND:
       if (wParam == IDM_ABOUT)
       {
         /* Draw and handle messages for the "About..." Dialog */
         DialogBox(hInst,
             MAKEINTRESOURCE(1),
             hWnd,
             MakeProcInstance((FARPROC) About, hInst));
       }
       else
       {
         /* Perform the default window processing */
         return(DefWindowProc(hWnd, message, wParam, lParam));
       }
       break;

     case WM_SIZE:
       /* Resize clock based on window size and redraw */
       ClockSize(hWnd, LOWORD(lParam), HIWORD(lParam), wParam);
       UpdateWindow(hWnd);
       break;

     case WM_DESTROY:
       /* Destroy clock's timer and tools before exiting */
       KillTimer(hWnd, TimerID);
       DeleteTools();
       PostQuitMessage(0);
       break;

     case WM_PAINT:
       {
         PAINTSTRUCT ps;

         /* Paint clock displaying current time */
         InvalidateRect(hWnd, (LPRECT) NULL, TRUE);
         BeginPaint(hWnd, (LPPAINTSTRUCT) &ps);
         ClockPaint(hWnd, ps.hdc, PAINTALL);
         EndPaint(hWnd, (LPPAINTSTRUCT) &ps);
       }
       break;

     case WM_TIMECHANGE:
     case WM_TIMER:
       /* Update clock to display new time */
       ClockTimer(hWnd);
       break;

     case WM_SYSCOLORCHANGE:
       /* Change tools to coincide with system window colors */
       DeleteTools();
       CreateTools();
       break;

     case WM_ERASEBKGND:
       {
         RECT rc;

         /* Paint over the entire client area */
         GetClientRect(hWnd, (LPRECT) &rc);
         FillRect((HDC) wParam, (LPRECT) &rc, hbrBackgnd);
       }
       break;

     default:
       /* Perform the default window processing */
       return(DefWindowProc(hWnd, message, wParam, lParam));
   }
   return(0L);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : CreateTools ()                                              *
  *                                                                         *
  *  PURPOSE  : Creates brushes and pens to coincide with the current       *
  *             system colors.                                              *
  *                                                                         *
  ***************************************************************************/

 int CreateTools()
 {
     hbrForegnd  = CreateSolidBrush(GetSysColor(COLOR_WINDOWTEXT));
     hbrBackgnd  = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
     hpenForegnd = CreatePen(0, 1, GetSysColor(COLOR_WINDOWTEXT));
     hpenBackgnd = CreatePen(0, 1, GetSysColor(COLOR_WINDOW));
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : DeleteTools ()                                              *
  *                                                                         *
  *  PURPOSE  : Destroys the brushes and pens created by CreateTools.       *
  *                                                                         *
  ***************************************************************************/

 int DeleteTools()
 {
     DeleteObject(hbrForegnd);
     DeleteObject(hbrBackgnd);
     DeleteObject(hpenForegnd);
     DeleteObject(hpenBackgnd);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockCreate ()                                              *
  *                                                                         *
  *  PURPOSE  : First, for drawing the clock, ClockCreate computes the      *
  *             aspect ratio and creates the necessary pens and brushes.    *
  *             Then, if this is the first instance of the app running,     *
  *             ClockCreate scales the circle table values according to the *
  *             aspect ratio. Finally, ClockCreate gets the initial time.   *
  *                                                                         *
  ***************************************************************************/

 int ClockCreate()
 {
   int  pos;      /* hand position index into the circle table */
   int  vertSize; /* height of the display in millimeters      */
   int  horzSize; /* width of the display in millimeters       */
   HDC  hDC;
   RECT rc;

   /* Get display size in (pixels X raster lines) */
   /* and in (millimeters X millimeters)          */
   hDC = GetDC(NULL);
   VertRes = GetDeviceCaps(hDC, VERTRES);
   HorzRes = GetDeviceCaps(hDC, HORZRES);
   vertSize= GetDeviceCaps(hDC, VERTSIZE);
   horzSize= GetDeviceCaps(hDC, HORZSIZE);
   ReleaseDC(NULL, hDC);

   /* Compute (raster lines / decimeter) and (pixels / decimeter) */
   AspectV = ((long) VertRes * MMPERDM) / (long) vertSize;
   AspectH = ((long) HorzRes * MMPERDM) / (long) horzSize;

   CreateTools();

   /* Scale cosines for aspect ratio if this is the first instance */
   if (bFirst)
   {
     lpCirTab = (POINT far *) GlobalLock(hCirTab);
     for (pos = 0; pos < HANDPOSITIONS; pos++)
     {
       lpCirTab[pos].y = VertEquiv(lpCirTab[pos].y);
     }
     GlobalUnlock(hCirTab);
         }

   GetTime(&oTime);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockSize (HWND, int, int, WORD)                            *
  *                                                                         *
  *  PURPOSE  : Resize the clock to the largest possible circle that will   *
  *             fit in the client area. If switching from not iconic to     *
  *             iconic, alter the timer to update every minute.  And if     *
  *             switching back to non iconic, restore the timer to update   *
  *             every second.                                               *
  *                                                                         *
  ***************************************************************************/

 int ClockSize(hWnd, newWidth, newHeight, sizeType)
   HWND hWnd;
   int  newWidth;
   int  newHeight;
   WORD sizeType;
 {
   /* Set ClockRect to bound the largest possible circle in the window */
   SetRect((LPRECT) &(ClockRect), 0, 0, newWidth, newHeight);
   CircleClock(newWidth, newHeight);

   if(sizeType == SIZEICONIC)
   {
     /* Update once every minute in the iconic state */
     KillTimer(hWnd, TimerID);
     SetTimer(hWnd, TimerID, (unsigned) ICON_TLEN, 0L);
     bIconic = TRUE;
   }
   else if (bIconic)
   {
     /* Update every second in the opened state (ignore tiling) */
     KillTimer(hWnd, TimerID);
     SetTimer(hWnd, TimerID, OPEN_TLEN, 0L);
     bIconic = FALSE;
   }
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockTimer (HWND)                                           *
  *                                                                         *
  *  PURPOSE  : Update the clock to reflect the most recent time.           *
  *                                                                         *
  ***************************************************************************/

 int ClockTimer(hWnd)
   HWND hWnd;
 {
   TIME nTime;
   HDC  hDC;

   GetTime(&nTime);

   /* It's possible to change any part of the system at any time through */
   /* the Control Panel. Check for any change in second, minute, or hour */
   if ((nTime.second != oTime.second) ||
       (nTime.minute != oTime.minute) ||
       (nTime.hour   != oTime.hour))
   {
     /* The time has changed -- update the clock */
     hDC = GetDC(hWnd);
     ClockPaint(hWnd, hDC, HANDPAINT);
     ReleaseDC(hWnd, hDC);
   }
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockPaint (HWND, HDC, int)                                 *
  *                                                                         *
  *  PURPOSE  : Paint the clock to display the most recent time.            *
  *                                                                         *
  ***************************************************************************/

 int ClockPaint(hWnd, hDC, paintType)
   HWND hWnd;
   HDC  hDC;
   int  paintType;
 {
   TIME nTime;

   SetBkMode(hDC, TRANSPARENT);

   lpCirTab = (POINT far *) GlobalLock(hCirTab);

   if (paintType == PAINTALL)
   {
     /* Paint entire clock -- face and hands */
     FillRect(hDC, (LPRECT) &ClockRect, hbrBackgnd);
     DrawFace(hDC);
     DrawFatHand(hDC, HourHandPos(oTime), hpenForegnd, HHAND);
     DrawFatHand(hDC, oTime.minute, hpenForegnd, MHAND);
     if (!bIconic)
     {
       /* Erase old second hand */
       DrawHand(hDC, oTime.second, hpenBackgnd, SECONDTIP, R2_NOT);
     }
         }
   else if (paintType == HANDPAINT)
   {
     GetTime(&nTime);

     if ((!bIconic) && (nTime.second != oTime.second))
     {
       /* Second has changed -- erase old second hand */
       DrawHand(hDC, oTime.second, hpenBackgnd, SECONDTIP, R2_NOT);
     }

     if ((nTime.minute != oTime.minute) || (nTime.hour != oTime.hour))
     {
       /* Hour and/or minute have changed -- update hands */
       if (bIconic)
       {
         /* Erase old minute and hour hands */
         DrawHand(hDC, oTime.minute,
                  hpenBackgnd, MINUTETIP, R2_COPYPEN);
         DrawHand(hDC, HourHandPos(oTime),
                  hpenBackgnd, HOURTIP, R2_COPYPEN);

         /* Draw new minute and hour hands */
         DrawHand(hDC, nTime.minute,
                  hpenForegnd, MINUTETIP, R2_COPYPEN);
         DrawHand(hDC, HourHandPos(nTime),
                  hpenForegnd, HOURTIP, R2_COPYPEN);

       }
       else
       {
         /* Erase old minute and hour fat hands */
         DrawFatHand(hDC, oTime.minute,
               hpenBackgnd, MHAND);
         DrawFatHand(hDC, HourHandPos(oTime),
               hpenBackgnd, HHAND);

         /* Draw new minute and hour fat hands */
         DrawFatHand(hDC, nTime.minute,
               hpenForegnd, MHAND);
         DrawFatHand(hDC, HourHandPos(nTime),
                     hpenForegnd, HHAND);
       }
     }

     if ((!bIconic) && (nTime.second != oTime.second))
     {
       /* second has changed -- draw new second hand */
       DrawHand(hDC, nTime.second,
                hpenBackgnd, SECONDTIP, R2_NOT);
     }

     /* Store most recent time */
     oTime.minute = nTime.minute;
     oTime.hour   = nTime.hour;
     oTime.second = nTime.second;
   }
   GlobalUnlock(hCirTab);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : DrawFace (HDC)                                              *
  *                                                                         *
  *  PURPOSE  : Draws the clock face.                                       *
  *                                                                         *
  ***************************************************************************/

 DrawFace(hDC)
   HDC hDC; /* device context to be used when drawing face */
 {
   int    pos;       /* hand position index into the circle table */
   int    dotHeight; /* height of the hour-marking dot            */
   int    dotWidth;  /* width of the hour-marking dot             */
   POINT  dotCenter; /* center point of the hour-marking dot      */
   RECT   rc;

   /* Compute hour-marking dot width, height, and center point */
   dotWidth = (MAXDOTWIDTH * (long) (ClockRect.right - ClockRect.left)) / Horz
   dotHeight = VertEquiv(dotWidth);

   if (dotHeight < MINDOTHEIGHT)
   {
     dotHeight = MINDOTHEIGHT;
   }

   if (dotWidth < MINDOTWIDTH)
   {
     dotWidth = MINDOTWIDTH;
   }

   dotCenter.x = dotWidth >> 1;
   dotCenter.y = dotHeight >> 1;

   /* Compute the clock center and radius */
   InflateRect((LPRECT) &ClockRect, -dotCenter.y, -dotCenter.x);
   ClockRadius = (long) ((ClockRect.right - ClockRect.left) >> 1);
   ClockCenter.x = ClockRect.left + ClockRadius;
   ClockCenter.y = ClockRect.top + ((ClockRect.bottom - ClockRect.top) >> 1);
   InflateRect((LPRECT) &ClockRect, dotCenter.y, dotCenter.x);

   /* Draw the large hour-marking dots and small minute-marking dots */
   for(pos = 0; pos < HANDPOSITIONS; pos++)
   {
     rc.top = (lpCirTab[pos].y * ClockRadius) / CIRTABSCALE + ClockCenter.y;
     rc.left = (lpCirTab[pos].x * ClockRadius) / CIRTABSCALE + ClockCenter.x;
     if (pos % 5)
     {
       if ((dotWidth > MINDOTWIDTH) && (dotHeight > MINDOTHEIGHT))
       {
         /* Draw small minute-marking dot */
         rc.right = rc.left + 1;
         rc.bottom = rc.top + 1;
         FillRect(hDC, (LPRECT) &rc, hbrForegnd);
       }
     }
     else
     {
       /* Draw large hour-marking dot */
       rc.right = rc.left + dotWidth;
       rc.bottom = rc.top + dotHeight;
       OffsetRect((LPRECT) &rc, -dotCenter.x, -dotCenter.y);
       FillRect(hDC, (LPRECT) &rc, hbrForegnd);
       }
   }
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : DrawHand (HDC, int, HPEN, int, int)                         *
  *                                                                         *
  *  PURPOSE  : Draws a thin hand with the specified pen in the specified   *
  *             hand position.                                              *
  *                                                                         *
  ***************************************************************************/

 DrawHand(hDC, pos, hPen, scale, patMode)
   HDC  hDC;     /* device context to be used when drawing hand */
   int  pos;     /* hand position index into the circle table   */
   HPEN hPen;    /* pen to be used when drawing hand            */
   int  scale;   /* ClockRadius percentage to scale drawing to  */
   int  patMode; /* pattern mode to be used when drawing hand   */
 {
   long radius;

   /* scale length of hand */
   radius = (ClockRadius * scale) / 100;

   /* set pattern mode for hand */
   SetROP2(hDC, patMode);

   /* select pen for hand */
   SelectObject(hDC, hPen);

   /* Draw thin hand */
   MoveTo(hDC, ClockCenter.x, ClockCenter.y);
   LineTo(hDC, ClockCenter.x + (int)((lpCirTab[pos].x * radius) / CIRTABSCALE)
         ClockCenter.y + (int)((lpCirTab[pos].y * radius) / CIRTABSCALE));
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : DrawFatHand (HDC, int, HPEN, BOOL)                          *
  *                                                                         *
  *  PURPOSE  : Draws a fat hand with the specified pen in the specified    *
  *             hand position.                                              *
  *                                                                         *
  ***************************************************************************/

 DrawFatHand(hDC, pos, hPen, hHand)
   HDC  hDC;     /* device context to be used when drawing hand */
   int  pos;     /* hand position index into the circle table   */
   HPEN hPen;    /* pen to be used when drawing hand            */
   BOOL hHand;   /* TRUE if drawing hour hand; FALSE otherwise  */
 {
   POINT ptTip;  /* coordinates for the tip of the hand        */
   POINT ptTail; /* coordinates for the tail of the hand       */
   POINT ptSide; /* coordinates for the side of the hand       */
   int   index;  /* position index into the circle table       */
   long  scale;  /* ClockRadius percentage to scale drawing to */

   /* set pattern mode for hand */
   SetROP2(hDC, 13);

   /* select pen for hand */
   SelectObject(hDC, hPen);

   /* compute coordinates for the side of the hand */
   scale = (ClockRadius * (hHand ? HOURSIDE : MINUTESIDE)) / 100;
   index = (pos + SIDESHIFT) % HANDPOSITIONS;
   ptSide.y = (lpCirTab[index].y * scale) / CIRTABSCALE;
   ptSide.x = (lpCirTab[index].x * scale) / CIRTABSCALE;

   /* compute coordinates for the tip of the hand */
   scale = (ClockRadius * (hHand ? HOURTIP : MINUTETIP)) / 100;
   ptTip.y = (lpCirTab[pos].y * scale) / CIRTABSCALE;
   ptTip.x = (lpCirTab[pos].x * scale) / CIRTABSCALE;

   /* compute coordinates for the tail of the hand */
   scale = (ClockRadius * (hHand ? HOURTAIL : MINUTETAIL)) / 100;
   index = (pos + TAILSHIFT) % HANDPOSITIONS;
   ptTail.y = (lpCirTab[index].y * scale) / CIRTABSCALE;
   ptTail.x = (lpCirTab[index].x * scale) / CIRTABSCALE;

   /* Draw tip of hand */
   MoveTo(hDC, ClockCenter.x + ptSide.x, ClockCenter.y + ptSide.y);
   LineTo(hDC, ClockCenter.x +  ptTip.x, ClockCenter.y +  ptTip.y);
   MoveTo(hDC, ClockCenter.x - ptSide.x, ClockCenter.y - ptSide.y);
   LineTo(hDC, ClockCenter.x +  ptTip.x, ClockCenter.y +  ptTip.y);

   /* Draw tail of hand */
   MoveTo(hDC, ClockCenter.x + ptSide.x, ClockCenter.y + ptSide.y);
   LineTo(hDC, ClockCenter.x + ptTail.x, ClockCenter.y + ptTail.y);
   MoveTo(hDC, ClockCenter.x - ptSide.x, ClockCenter.y - ptSide.y);
   LineTo(hDC, ClockCenter.x + ptTail.x, ClockCenter.y + ptTail.y);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : CircleClock (int, int)                                      *
  *                                                                         *
  *  PURPOSE  : Resizes the clock rectangle to keep the face circular.      *
  *                                                                         *
  ***************************************************************************/

 CircleClock(maxWidth, maxHeight)
   int maxWidth;    /* the maximum width of the clock face         */
   int maxHeight;   /* the maximum height of the clock face        */
 {
   int clockHeight; /* tallest height that will keep face circular */
   int clockWidth;  /* widest width that will keep face circular   */

   if (maxWidth > HorzEquiv(maxHeight))
   {
     /* too wide -- decrease width to keep face circular */
     clockWidth = HorzEquiv(maxHeight);
     ClockRect.left += (maxWidth - clockWidth) >> 1;
     ClockRect.right = ClockRect.left + clockWidth;
   }
   else
   {
     /* too tall -- decrease height to keep face circular */
     clockHeight = VertEquiv(maxWidth);
     ClockRect.top += (maxHeight - clockHeight) >> 1;
     ClockRect.bottom = ClockRect.top + clockHeight;
   }
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : WinMain (HANDLE, HANDLE, LPSTR, int)                        *
  *                                                                         *
  *  PURPOSE  : Calls the initialization function, creates the main appli-  *
  *             cation window, and enters the message loop.                 *
  *                                                                         *
  ***************************************************************************/

 int PASCAL WinMain(hInstance, hPrev, lpszCmdLine, cmdShow)
   HANDLE hInstance;
   HANDLE hPrev;
   LPSTR  lpszCmdLine;
   int    cmdShow;
 {
   HWND  hWnd;
   MSG   msg;
   HMENU hMenu;
   TIME  nTime;
   int   sysWidth;  /* width of left and right frames                  */
   int   sysHeight; /* height of caption bar and top and bottom frames */
   int   width;     /* width of entire clock window                    */
   int   height;    /* height of entire clock window                   */

   hInst = hInstance;

   LoadString(hInst, IDS_APPNAME, (LPSTR) szBuffer, BUFLEN);

   if (!hPrev)
   {
     /* First instance -- register window class */
     if (!ClockInit())
       return(FALSE);
         }
   else
   {
     /* Not first instance -- get circle table and reset bFirst flag */
     GetInstanceData(hPrev, (PSTR) &hCirTab, sizeof(HANDLE));
     bFirst = FALSE;
         }

   ClockCreate();

   /* compute window height and width */
   sysWidth  = GetSystemMetrics(SM_CXFRAME) * 2;
   sysHeight = GetSystemMetrics(SM_CYCAPTION) + (GetSystemMetrics(SM_CYFRAME)
   width = (HorzRes / 3) + sysWidth;
   height = VertEquiv(width) + sysHeight;

   hWnd = CreateWindow( (LPSTR) szBuffer, /* class name              */
                              (LPSTR) szBuffer, /* The window name         */
                              WS_TILEDWINDOW,   /* window style            */
                              CW_USEDEFAULT,    /* use default positioning */
                              0,                /* y not used              */
                              width,            /* window width            */
            height,           /* window height           */
                              NULL,             /* NULL parent handle      */
                              NULL,             /* NULL menu/child handle  */
                              hInst,            /* program instance        */
                              NULL              /* NULL data structure ref.*/
          );

   GetTime(&nTime);
   GetTime(&oTime);
   while ((nTime.second == oTime.second) &&
                (nTime.minute == oTime.minute) &&
                (nTime.hour   == oTime.hour)     )
   {
     GetTime(&oTime);
   }

   if (!SetTimer(hWnd, TimerID, OPEN_TLEN, 0L))
   {
     LPSTR szTooMany;

     /* 16 public timers already in use -- post error and exit */
     szTooMany = (LPSTR)(unsigned long) LocalAlloc(LPTR, 40);
     LoadString(hInst, IDS_TOOMANY, szTooMany, 40);
     MessageBox((HWND) NULL, szTooMany, (LPSTR) szBuffer,
          MB_OK | MB_ICONHAND | MB_SYSTEMMODAL);
     DeleteTools();
     return(FALSE);
   }

   /* Add the "About..." menu item to the bottom of the system menu */
   LoadString(hInst, IDS_ABOUTMENU, (LPSTR) szBuffer, BUFLEN);
   hMenu = GetSystemMenu(hWnd, FALSE);
   ChangeMenu(hMenu, 0, (LPSTR) szBuffer, IDM_ABOUT, MF_APPEND | MF_STRING);

   ShowWindow(hWnd, cmdShow);

   /* Process messages until program termination */
   while (GetMessage((LPMSG) &msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) &msg);
     DispatchMessage((LPMSG) &msg);
   }
   return(msg.wParam);
 }


 /***************************************************************************
  *                                                                         *
  *  FUNCTION : ClockInit ()                                                *
  *                                                                         *
  *  PURPOSE  : Registers the applicatoin windwo class and initializes the  *
  *             circle values for the clock face.                           *
  *                                                                         *
  ***************************************************************************/

 ClockInit()
 {
   PWNDCLASS pClockClass;
   HANDLE    hRes;
   char      szData[5];

   pClockClass = (PWNDCLASS) LocalAlloc(LPTR, sizeof(WNDCLASS));

   pClockClass->lpszClassName = (LPSTR) szBuffer;
   pClockClass->hbrBackground = (HBRUSH) NULL;
   pClockClass->style         = CS_VREDRAW | CS_HREDRAW | CS_BYTEALIGNCLIENT;
   pClockClass->hInstance     = hInst;
   pClockClass->lpfnWndProc   = ClockWndProc;
   pClockClass->hCursor       = LoadCursor(NULL, IDC_ARROW);
   pClockClass->hIcon         = NULL;

   if (!RegisterClass((LPWNDCLASS) pClockClass))
   {
     /* Error registering class -- return */
     return(FALSE);
   }

   LocalFree((HANDLE) pClockClass);

   /* Load in pre-computed circle table cosine values from resource file */
   LoadString(hInst, IDS_DATA, (LPSTR) szData, 5);
   hRes = FindResource(hInst, (LPSTR) szBuffer, (LPSTR) szData);
   if (!hRes)
   {
     /* Could not find circle table resource data -- return */
     return(FALSE);
   }

   hCirTab = LoadResource(hInst, hRes);
   LockResource(hCirTab);

   return(TRUE);
 }


 CURSOR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\CURSOR\CURSOR.C

 /****************************************************************************

     PROGRAM: Cursor.c

     PURPOSE: Demonstrates how to manipulate a cursor and select a region

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box
         sieve() - time consuming function, generates primes

 ****************************************************************************/

 #include "windows.h"
 #include "cursor.h"

 HANDLE hInst;

 char str[255];                              /* general-purpose string buffer

 HCURSOR hSaveCursor;                        /* handle to current cursor
 HCURSOR hHourGlass;                         /* handle to hourglass cursor

 BOOL bTrack = FALSE;                        /* TRUE if left button clicked
 int OrgX = 0, OrgY = 0;                     /* original cursor position
 int PrevX = 0, PrevY = 0;                   /* current cursor position
 int X = 0, Y = 0;                           /* last cursor position
 RECT Rect;                                  /* selection rectangle

 POINT ptCursor;                             /* x and y coordinates of cursor
 int repeat = 1;                             /* repeat count of keystroke

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     MessageBox (
           GetFocus ()
         , "Use the mouse button in this program for an example of graphics "
                         "selection, or the <Enter> key for an example of "
                         "using a special cursor to reflect a program state."
         , "Cursor Sample Application"
         , MB_ICONASTERISK | MB_OK
     );

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(hInstance, "bullseye");
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "CursorMenu";
     wc.lpszClassName = "CursorWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hWnd;

     hInst = hInstance;

     strcpy(str,"");

     hHourGlass = LoadCursor(NULL, IDC_WAIT);

     hWnd = CreateWindow(
         "CursorWClass",
         "Cursor Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hWnd)
         return (FALSE);

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

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND     - application menu (About dialog box)
         WM_CHAR        - ASCII key value received
         WM_LBUTTONDOWN - left mouse button
         WM_MOUSEMOVE   - mouse movement
         WM_LBUTTONUP   - left button released
         WM_KEYDOWN     - key pressed
         WM_KEYUPS      - key released
         WM_PAINT       - update window
   WM_DESTROY     - destroy window

     COMMENTS:

         When the left mouse button is pressed, btrack is set to TRUE so that
         the code for WM_MOUSEMOVE will keep track of the mouse and update
         the box accordingly.  Once the button is released, btrack is set to
         FALSE, and the current position is saved.  Holding the SHIFT key
         while pressing the left button will extend the current box rather
         then erasing it and starting a new one.

         When an arrow key is pressed, the cursor is repositioned in the
         direction of the arrow key.  A repeat count is kept so that the
         longer the user holds down the arrow key, the faster it will move.
         As soon as the key is released, the repeat count is set to 1 for
         normal cursor movement.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;
     HDC hDC;

     switch (message) {
   case WM_COMMAND:
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,
         "AboutBox",
         hWnd,
         lpProcAbout);

     FreeProcInstance(lpProcAbout);
     break;
       }
       else
     return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CHAR:
             if (wParam == '\r') {
                 SetCapture(hWnd);

                 /* Set the cursor to an hourglass */

                 hSaveCursor = SetCursor(hHourGlass);

                 strcpy (str, "Calculating prime numbers...");
                 InvalidateRect (hWnd, NULL, TRUE);
                 UpdateWindow (hWnd);
                 wsprintf(str, "Calculated %d primes.       ", sieve());
                 InvalidateRect (hWnd, NULL, TRUE);
                 UpdateWindow (hWnd);

                 SetCursor(hSaveCursor);          /* Restores previous cursor
                 ReleaseCapture();
             }
             break;

         case WM_LBUTTONDOWN:
             bTrack = TRUE;
             strcpy (str, "");
             PrevX = LOWORD(lParam);
             PrevY = HIWORD(lParam);
             if (!(wParam & MK_SHIFT)) {       /* If shift key is not pressed
                 OrgX = LOWORD(lParam);
                 OrgY = HIWORD(lParam);
             }
             InvalidateRect (hWnd, NULL, TRUE);
             UpdateWindow (hWnd);

             /* Capture all input even if the mouse goes outside of window */

             SetCapture(hWnd);
             break;

         case WM_MOUSEMOVE:
             {
                 RECT        rectClient;
                 int         NextX;
                 int         NextY;

                 if (bTrack) {
                     NextX = LOWORD(lParam);
                     NextY = HIWORD(lParam);

                     /* Do not draw outside the window's client area */

                     GetClientRect (hWnd, &rectClient);
                     if (NextX < rectClient.left) {
                         NextX = rectClient.left;
                     } else if (NextX >= rectClient.right) {
                         NextX = rectClient.right - 1;
                     }
                     if (NextY < rectClient.top) {
                         NextY = rectClient.top;
                     } else if (NextY >= rectClient.bottom) {
                         NextY = rectClient.bottom - 1;
                     }

                     /* If the mouse position has changed, then clear the */
                     /* previous rectangle and draw the new one.          */

                     if ((NextX != PrevX) || (NextY != PrevY)) {
                         hDC = GetDC(hWnd);
                         SetROP2(hDC, R2_NOT);          /* Erases the previous
                         MoveTo(hDC, OrgX, OrgY);
                         LineTo(hDC, OrgX, PrevY);
                         LineTo(hDC, PrevX, PrevY);
                         LineTo(hDC, PrevX, OrgY);
                         LineTo(hDC, OrgX, OrgY);

                         /* Get the current mouse position */

                         PrevX = NextX;
                         PrevY = NextY;
                         MoveTo(hDC, OrgX, OrgY);        /* Draws the new box
                         LineTo(hDC, OrgX, PrevY);
                         LineTo(hDC, PrevX, PrevY);
                         LineTo(hDC, PrevX, OrgY);
                         LineTo(hDC, OrgX, OrgY);
                         ReleaseDC(hWnd, hDC);
                     }
                 }
             }
             break;

         case WM_LBUTTONUP:
       bTrack = FALSE;        /* No longer creating a selection */
       ReleaseCapture();        /* Releases hold on mouse input */

       X = LOWORD(lParam);       /* Saves the current value      */
             Y = HIWORD(lParam);
             break;

         case WM_KEYDOWN:
             if (wParam != VK_LEFT && wParam != VK_RIGHT
                     && wParam != VK_UP && wParam != VK_DOWN)
                 break;

             GetCursorPos(&ptCursor);

             /* Convert screen coordinates to client coordinates */

             ScreenToClient(hWnd, &ptCursor);
             repeat++;                           /* Increases the repeat rate

             switch (wParam) {

             /* Adjust cursor position according to which key was pressed. */

                 case VK_LEFT:
                     ptCursor.x -= repeat;
                     break;

                 case VK_RIGHT:
                     ptCursor.x += repeat;
                     break;

                 case VK_UP:
                     ptCursor.y -= repeat;
                     break;

                 case VK_DOWN:
                     ptCursor.y += repeat;
                     break;

             }

             /* Get the client boundaries */

             GetClientRect(hWnd, &Rect);

             /* Do not draw outside the window's client area */

             if (ptCursor.x >= Rect.right)
                 ptCursor.x = Rect.right - 1;
             else if (ptCursor.x < Rect.left)
                 ptCursor.x = Rect.left;
             if (ptCursor.y >= Rect.bottom)
                 ptCursor.y = Rect.bottom - 1;
             else if (ptCursor.y < Rect.top)
                 ptCursor.y = Rect.top;

             /* Convert the coordinates to screen coordinates */

             ClientToScreen(hWnd, &ptCursor);
             SetCursorPos(ptCursor.x, ptCursor.y);
             break;

         case WM_KEYUP:
             repeat = 1;                          /* Clears the repeat count.
             break;

         case WM_ACTIVATE:
             if (!GetSystemMetrics(SM_MOUSEPRESENT)) {
                 if (!HIWORD(lParam)) {
                     if (wParam) {
                         SetCursor(LoadCursor(hInst, "bullseye"));
                         ptCursor.x = X;
                         ptCursor.y = Y;
                         ClientToScreen(hWnd, &ptCursor);
                         SetCursorPos(ptCursor.x, ptCursor.y);
                     }
                     ShowCursor(wParam);
                 }
             }
             break;

         case WM_PAINT:
             {
                 PAINTSTRUCT     ps;

                 hDC = BeginPaint (hWnd, &ps);
                 if (OrgX != PrevX || OrgY != PrevY) {
                     MoveTo(hDC, OrgX, OrgY);
                     LineTo(hDC, OrgX, PrevY);
                     LineTo(hDC, PrevX, PrevY);
                     LineTo(hDC, PrevX, OrgY);
                     LineTo(hDC, OrgX, OrgY);
                 }
                 TextOut (hDC, 1, 1, str, strlen (str));
                 EndPaint (hWnd, &ps);
             }
             break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 /****************************************************************************

     FUNCTION: Sieve()

     PURPOSE:  Example of time consuming process

     COMMENTS:

   Sieve of Eratosthenes, BYTE, Volume 8, Number 1, by Jim Gilbreath
   and Gary Gilbreath.  Code changed to give correct results.

   One could return the count, and after restoring the cursor, use
   sprintf() to copy the information to a string which could then be
   put up in a MessageBox().

 ****************************************************************************/

  NITER  20           /* number of iterations */
 #define SIZE  8190

 char flags[SIZE+1]={ 0};

 sieve() {
     int i,k;
     int iter, count;

     for (iter = 1; iter <= NITER; iter++) {   /* Does sieve NITER times */
   count = 0;
   for (i = 0; i <= SIZE; i++)     /* Sets all flags TRUE     */
       flags[i] = TRUE;

   for (i = 2; i <= SIZE; i++) {
       if (flags[i] ) {          /* Found a prime?      */
     for (k = i + i; k <= SIZE; k += i)
         flags[k] = FALSE;       /* Cancelsits multiples */
     count++;
       }
   }
     }
     return (count);
 }


 DEFDLG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DEFPROCS\DEFDLG.C


 /*--------------------------------------------------------------------------*
 /*                      */
 /*  DefDlgProc() -                  */
 /*                      */
 /*--------------------------------------------------------------------------*

 LONG FAR PASCAL DefDlgProc(hwnd, message, wParam, lParam)

 register HWND hwnd;
 register WORD message;
 WORD        wParam;
 LONG        lParam;

 {
   HWND        hwndT1;
   HWND        hwndT2;
   int        result;

   if (!CheckHwnd(hwnd))
       return(NULL);

   ((PDLG)hwnd)->resultWP = 0L;

   if (((PDLG)hwnd)->lpfnDlg == NULL ||
       !(result = (*((PDLG)hwnd)->lpfnDlg)(hwnd, message, wParam, lParam)))
     {
       switch (message)
   {
     case WM_ERASEBKGND:
         FillWindow(hwnd, hwnd, (HDC)wParam, (HBRUSH)CTLCOLOR_DLG);
         return((LONG)TRUE);

     case WM_SHOWWINDOW:
         /* If hiding the window, save the focus. If showing the window
          * by means of a SW_* command and the fEnd bit is set, do not
          * pass to DWP so it won't get shown.
          */
         if (!wParam && ((PDLG)hwnd)->hwndFocusSave == NULL)
       ((PDLG)hwnd)->hwndFocusSave = hwndFocus;
         else if (LOWORD(lParam) != 0 && ((PDLG)hwnd)->fEnd)
       break;
         goto CallDWP;

     case WM_ACTIVATE:
         fDialog = FALSE;
         if (wParam)
     {
       fDialog = TRUE;
       if (((PDLG)hwnd)->hwndFocusSave)
         {
           SetFocus(((PDLG)hwnd)->hwndFocusSave);

           /* Set to NULL so we don't reset if we get more than
        one activate message. */
           ((PDLG)hwnd)->hwndFocusSave = NULL;
         }
     }
         else if (hwndFocus && IsChild(hwnd, hwndFocus) &&
            ((PDLG)hwnd)->hwndFocusSave == NULL)
     {
       /* Must remember focus if deactivated */
       ((PDLG)hwnd)->hwndFocusSave = hwndFocus;
     }
         break;

     case WM_SETFOCUS:
               if (!((PDLG)hwnd)->fEnd)
                   /* Don't set the focus if we are ending this dialog box
        */
               DlgSetFocus(GetFirstTab(hwnd));
         break;

     case WM_CLOSE:
         /* Make sure cancel button is not disabled before sending the
          * IDCANCEL.  Note that we need to do this as a message instead
          * of directly calling the dlg proc so that any dialog box
          * filters get this.
          */
         hwndT1 = GetDlgItem(hwnd, IDCANCEL);
         if (hwndT1 && TestWF(hwndT1, WFDISABLED))
       MessageBeep(0);
         else
       PostMessage(hwnd, WM_COMMAND, IDCANCEL, 0L);
         break;

     case WM_NCDESTROY:
               fDialog = FALSE;      /* clear this flag */
         if (!(hwnd->style & DS_LOCALEDIT))
     {
       if (((PDLG)hwnd)->hData)
         {
           GlobalUnWire(((PDLG)hwnd)->hData);
           ReleaseEditDS(((PDLG)hwnd)->hData);
         }
     }
         /* Delete the user defined font if any */
         if (((PDLG)hwnd)->hUserFont)
       DeleteObject(((PDLG)hwnd)->hUserFont);

         /* Gotta let DefWindowProc do its thing here or we won't
          * get all of the little chunks of memory freed for this
          * window (szName and rgwScroll).
          */
         DefWindowProc(hwnd, message, wParam, lParam);
         break;

     case DM_SETDEFID:
               if (!(((PDLG)hwnd)->fEnd) && (((PDLG)hwnd)->result != wParam))
                 {
                   /* Make sure that the new default button has the highlight.
        * We need to blow this off if we are ending the dialog box
        * because hwnd->result is no longer a default window id but
        * rather the return value of the dialog box.
        */
                   /* Catch the case of setting the defid to null or setting
        * the defid to something else when it was initially null.
        */
                   CheckDefPushButton(hwnd,
                        (((PDLG)hwnd)->result ?
                                      GetDlgItem(hwnd, ((PDLG)hwnd)->result) :
                                      NULL),
                        (wParam ? GetDlgItem(hwnd, wParam) : NULL));
                ((PDLG)hwnd)->result = wParam;
                 }
         return(TRUE);

     case DM_GETDEFID:
         return(MAKELONG(((PDLG)hwnd)->result, DC_HASDEFID));

     /* This message was added so that user defined controls that want
      * tab keys can pass the tab off to the next/previous control in the
      * dialog box.  Without this, all they could do was set the focus
      * which didn't do the default button stuff.
      */
     case WM_NEXTDLGCTL:
         hwndT2 = hwndFocus;
         if (LOWORD(lParam))
     {
       if (hwndT2 == NULL)
           hwndT2 = hwnd;

       /* wParam contains the hwnd of the ctl to set focus to. */
       hwndT1 = (HWND)wParam;
     }
         else
     {
       if (hwndT2 == NULL)
         {
           /* Set focus to the first tab item. */
           hwndT1 = GetFirstTab(hwnd);
           hwndT2 = hwnd;
         }
       else
         {
           /* If window with focus not a dlg ctl, ignore message. */
           if (!IsChild(hwnd, hwndT2))
         return(TRUE);

           /* wParam = TRUE for previous, FALSE for next */
           hwndT1 = GetNextDlgTabItem(hwnd, hwndT2, wParam);
         }
     }

         DlgSetFocus(hwndT1);
         CheckDefPushButton(hwnd, hwndT2, hwndT1);
         return(TRUE);

     case WM_LBUTTONDOWN:
     case WM_NCLBUTTONDOWN:
         hwndT1 = hwndFocus;
         if (hwndT1->pcls->lpfnWndProc == ComboBoxCtlWndProc)
       /* If user clicks anywhere in dialog box and a combo box (or
        * the editcontrol of a combo box) has the focus, then hide
        * it's listbox.
        */
       SendMessage(hwndT1,CB_SHOWDROPDOWN, FALSE, 0L);
         else
         if (hwndT1->pcls->lpfnWndProc == EditWndProc &&
       hwndT1->hwndParent->pcls->lpfnWndProc==ComboBoxCtlWndProc)
     {
       SendMessage(hwndT1->hwndParent,CB_SHOWDROPDOWN, FALSE, 0L);
     }
         /* Always send the message off to DefWndProc */
         goto CallDWP;

     case WM_GETFONT:
         return(((PDLG)hwnd)->hUserFont);

     case WM_VKEYTOITEM:
     case WM_COMPAREITEM:
     case WM_CHARTOITEM:
         /* We need to return the 0 the app may have returned for these
          * items instead of calling defwindow proc.
          */
         return(result);

     default:
 CallDWP:
         return(DefWindowProc(hwnd, message, wParam, lParam));
   }
     }

   /* Must return brush which apps dlgfn returns. */
   if (message == WM_CTLCOLOR ||
       message == WM_COMPAREITEM ||
       message == WM_VKEYTOITEM ||
       message == WM_CHARTOITEM)
       return(result);

   return(((PDLG)hwnd)->resultWP);
 }


 DEFWND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DEFPROCS\DEFWND.C

 /*--------------------------------------------------------------------------*
 /*                      */
 /*  DefWindowProc() -                  */
 /*                      */
 /*--------------------------------------------------------------------------*

 LONG FAR PASCAL DefWindowProc(hwnd, message, wParam, lParam)

 register HWND hwnd;
 WORD        message;
 register WORD wParam;
 LONG        lParam;

 {
   int        i;
   HDC        hdc;
   PAINTSTRUCT ps;
   HICON        hIcon;
   RECT        rc;
   HANDLE      hCurs;
   HBRUSH      hbr;
   HWND        hwndT;

   if (!CheckHwnd(hwnd))
       return((DWORD)FALSE);

   switch (message)
     {
       case WM_NCACTIVATE:
     if (wParam != 0)
         SetWF(hwnd, WFFRAMEON);
     else
         ClrWF(hwnd, WFFRAMEON);

     if (TestWF(hwnd, WFVISIBLE) && !TestWF(hwnd, WFNONCPAINT))
       {
         hdc = GetWindowDC(hwnd);
         DrawCaption(hwnd, hdc, TRUE, TestWF(hwnd, WFFRAMEON));
         InternalReleaseDC(hdc);
         if (TestWF(hwnd,WFMINIMIZED))
       RedrawIconTitle(hwnd);
       }
     return(TRUE);

       case WM_NCHITTEST:
     return(FindNCHit(hwnd, lParam));

       case WM_NCCALCSIZE:
     CalcClientRect(hwnd, (LPRECT)lParam);
     break;

       case WM_NCLBUTTONDOWN:
   {
     WORD       cmd;
     RECT       rcWindow;
     RECT       rcCapt;
     RECT       rcInvert;
     RECT       rcWindowSave;

     cmd = 0;

     switch(wParam)
       {
         case HTZOOM:
         case HTREDUCE:
       GetWindowRect(hwnd, (LPRECT)&rcWindow);
       CopyRect((LPRECT)&rcWindowSave, (LPRECT)&rcWindow);

       if (TestWF(hwnd, WFSIZEBOX))
           InflateRect((LPRECT)&rcWindow,
                 -cxSzBorderPlus1, -cySzBorderPlus1);
       else
           InflateRect((LPRECT)&rcWindow, -cxBorder, -cyBorder);

       rcCapt.right = rcWindow.right + cxBorder;
                   rcCapt.left = rcWindow.right - oemInfo.bmReduce.cx-cxBorder

       if (wParam == HTREDUCE)
           cmd = SC_MINIMIZE;
       else if (TestWF(hwnd, WFMAXIMIZED))
           cmd = SC_RESTORE;
       else
           cmd = SC_MAXIMIZE;

       if (wParam == HTREDUCE && TestWF(hwnd, WFMAXBOX))
                       OffsetRect((LPRECT)&rcCapt, -oemInfo.bmReduce.cx, 0);

       rcCapt.top = rcWindow.top;
       rcCapt.bottom = rcCapt.top + cyCaption;

       CopyRect((LPRECT)&rcInvert, (LPRECT)&rcCapt);
                   InflateRect((LPRECT)&rcInvert, -cxBorder, -cyBorder);

                   rcInvert.right += cxBorder;
       rcInvert.left += cxBorder;

       /* Converting to window coordinates. */
       OffsetRect((LPRECT)&rcInvert,
            -(rcWindowSave.left + cxBorder),
            -(rcWindowSave.top + cyBorder));
       /* Wait for the BUTTONUP message and see if cursor is still
        * in the Minimize or Maximize box.
        *
        * NOTE: rcInvert is in window coords, rcCapt is in screen
        * coords
        */
                   if (!DepressTitleButton(hwnd, rcCapt, rcInvert, wParam))
           cmd = 0;

       break;

         default:
       if (wParam >= HTSIZEFIRST && wParam <= HTSIZELAST)
           /* Change HT into a MV command. */
           cmd = SC_SIZE + (wParam - HTSIZEFIRST + MVSIZEFIRST);
       }

     if (cmd != 0)
       {
         /* For SysCommands on system menu, don't do if
          * menu item is disabled.
          */
         if (TestWF(hwnd, WFSYSMENU))
     {
                   /* don't check old app child windows
        */
       if (LOWORD(GetExpWinVer(hwnd->hInstance)) >= VER ||
           !TestwndChild(hwnd))
         {
           SetSysMenu(hwnd);
           if (GetMenuState(GetSysMenuHandle(hwnd), cmd & 0xFFF0,
         MF_BYCOMMAND) & (MF_DISABLED | MF_GRAYED))
         break;
         }
     }
         SendMessage(hwnd, WM_SYSCOMMAND, cmd, lParam);
         break;
       }
     /*** FALL THRU ***/
   }

       case WM_NCMOUSEMOVE:
       case WM_NCLBUTTONUP:
       case WM_NCLBUTTONDBLCLK:
     HandleNCMouseGuys(hwnd, message, wParam, lParam);
     break;

       case WM_CANCELMODE:
     if (hwndCapture == hwnd && pfnSB != NULL)
         EndScroll(hwnd, TRUE);

           if (fMenu && hwndMenu == hwnd)
               EndMenu();

     /* If the capture is still set, just release at this point.
      * Can put other End* functions in later.
      */
     if (hwnd == hwndCapture)
         ReleaseCapture();
     break;

       case WM_NCCREATE:
     if (TestWF(hwnd, (WFHSCROLL | WFVSCROLL)))
         if (InitPwSB(hwnd) == NULL)
       return((LONG)FALSE);

     return((LONG)DefSetText(hwnd, ((LPCREATESTRUCT)lParam)->lpszName));

       case WM_NCDESTROY:
     if (hwnd->hName)
         hwnd->hName = TextFree(hwnd->hName);
     break;

       case WM_NCPAINT:
     /* Force the drawing of the menu. */
     SetWF(hwnd, WFMENUDRAW);
     DrawWindowFrame(hwnd, (HRGN)wParam);
     ClrWF(hwnd, WFMENUDRAW);
     break;

       case WM_SETTEXT:
     DefSetText(hwnd, (LPSTR)lParam);
     if (TestWF(hwnd, WFVISIBLE))
             {
         if (TestWF(hwnd,WFMINIMIZED))
     {
       ShowIconTitle(hwnd,FALSE);
       ShowIconTitle(hwnd,TRUE);
     }
         else if (TestWF(hwnd, WFBORDERMASK) == (BYTE)LOBYTE(WFCAPTION))
     {
       hdc = GetWindowDC(hwnd);
       DrawCaption(hwnd, hdc, FALSE, TestWF(hwnd, WFFRAMEON));
       InternalReleaseDC(hdc);
     }
             }
     break;

       case WM_GETTEXT:
     if (wParam)
             {
               if (hwnd->hName)
             return (DWORD)TextCopy(hwnd->hName,(LPSTR)lParam,wParam);

               /* else Null terminate the text buffer since there is no text.
          */
         ((LPSTR)lParam)[0] = NULL;
             }
     return (0L);


       case WM_GETTEXTLENGTH:
     if (hwnd->hName)
         return(lstrlen(TextPointer(hwnd->hName)));

           /* else */
           return(0L);

       case WM_CLOSE:
     DestroyWindow(hwnd);
     break;

       case WM_PAINT:
     BeginPaint(hwnd, (LPPAINTSTRUCT)&ps);
     EndPaint(hwnd, (LPPAINTSTRUCT)&ps);
     break;

       case WM_PAINTICON:
           /* Draw the icon through the window DC if app used own DC. If own D
      * is used the mapping mode may not be MM_TEXT.
      */
           BeginPaint(hwnd, (LPPAINTSTRUCT)&ps);
           if (TestCF(hwnd, CFOWNDC) || TestCF(hwnd, CFCLASSDC))
             {
               /* If owndc, do the end paint now so that the
          * erasebackgrounds/validate regions go through properly. Then
          * we get a clean window dc to draw the icon into.
          */
               InternalEndPaint(hwnd, (LPPAINTSTRUCT)&ps, TRUE);
               hdc = GetWindowDC(hwnd);
             }
           else
             {
               hdc = ps.hdc;
             }

     /* wParam is TRUE to draw icon, FALSE to ignore paint. */
     if (wParam)
       {
               hIcon = (HICON)(PCLS)(hwnd->pcls)->hIcon;
               GetClientRect(hwnd, (LPRECT)&rc);

               rc.left = (rc.right - rgwSysMet[SM_CXICON]) >> 1;
         rc.top = (rc.bottom - rgwSysMet[SM_CYICON]) >> 1;

         DrawIcon(hdc, rc.left, rc.top, hIcon);
       }

     /* Delete the update region. */
           if (TestCF(hwnd, CFOWNDC) || TestCF(hwnd, CFCLASSDC))
             {
               InternalReleaseDC(hdc);
               /* ValidateRect(hwnd, NULL); */
             }
           else
               InternalEndPaint(hwnd, (LPPAINTSTRUCT)&ps, TRUE);
     break;

       case WM_ICONERASEBKGND:
           /* Erase the icon through the window DC if app used own DC. If own
      * DC is used the mapping mode may not be MM_TEXT.
      */
           if (TestCF(hwnd, CFOWNDC) || TestCF(hwnd, CFCLASSDC))
           hdc = GetWindowDC(hwnd);
           else
            hdc = (HDC)wParam;

           if (TestWF(hwnd, WFCHILD))    /* for MDI child icons */
             {
               if ((hbr = GetBackBrush(hwnd->hwndParent)) == NULL)
     {
                   /* No brush, punt. */
                   goto AbortIconEraseBkGnd;
                 }
               else
                   goto ICantBelieveIUsedAGoToStatement;
       }

     if (hbmWallpaper)
             {
               /* Since desktop bitmaps are done on a wm_paint message (and no
          * erasebkgnd), we need to call the paint proc with our dc
          */
               PaintDesktop(hdc);
               /* SendMessage(hwndDesktop, WM_ERASEBKGND, hdc, 0L);*/
             }
     else
       {
         hbr = sysClrObjects.hbrDesktop;
 ICantBelieveIUsedAGoToStatement:
         FillWindow(hwnd->hwndParent,hwnd,hdc,hbr);
       }

 AbortIconEraseBkGnd:
           if (TestCF(hwnd, CFOWNDC) || TestCF(hwnd, CFCLASSDC))
           InternalReleaseDC(hdc);

     return((LONG)TRUE);

       case WM_ERASEBKGND:
     if ((hbr = GetBackBrush(hwnd)) != NULL)
       {
         FillWindow(hwnd, hwnd, (HDC)wParam, hbr);
         return((LONG)TRUE);
       }
     break;

       case WM_QUERYOPEN:
       case WM_QUERYENDSESSION:
     return((LONG)TRUE);

       case WM_SYSCOMMAND:
     SysCommand(hwnd, wParam, lParam);
     break;

       case WM_KEYDOWN:
     if (wParam == VK_F10)
         fF10Status = TRUE;
     break;

       case WM_SYSKEYDOWN:
     /* Is the ALT key down? */
     if (HIWORD(lParam) & SYS_ALTERNATE)
       {
         /* Toggle the fMenuStatus iff this is NOT a repeat KEYDOWN
          * message; Only if the prev key state was 0, then this is the
          * first KEYDOWN message and then we consider toggling menu
                * status;
          */
         if((HIWORD(lParam) & SYS_PREVKEYSTATE) == 0)
           {
             /* Don't have to lock hwndActive because it's processing this
          key. */
             if ((wParam == VK_MENU) && (!fMenuStatus))
           fMenuStatus = TRUE;
             else
           fMenuStatus = FALSE;
     }

         fF10Status = FALSE;

         DWP_ProcessVirtKey(wParam);
       }
     else
       {
         if (wParam == VK_F10)
       fF10Status = TRUE;
         else
     {
       if (wParam == VK_ESCAPE)
         {
           if(GetKeyState(VK_SHIFT) < 0)
                SendMessage(hwnd, WM_SYSCOMMAND,
                SC_KEYMENU, (DWORD)MENUSYSMENU);
         }
     }
       }
     break;

       case WM_KEYUP:
       case WM_SYSKEYUP:
     /* press and release F10 or ALT.Send this only to top-level windows,
      * otherwise MDI gets confused.  The fix in which DefMDIChildProc()
      * passed up the message was insufficient in the case a child window
      * of the MDI child had the focus.
      */
     if ((wParam == VK_MENU && (fMenuStatus == TRUE)) ||
         (wParam == VK_F10 && fF10Status) )
         SendMessage(GetTopLevelWindow(hwnd), WM_SYSCOMMAND, SC_KEYMENU,
       (DWORD)0);

     fF10Status = fMenuStatus = FALSE;
     break;

       case WM_SYSCHAR:
     /* If syskey is down and we have a char... */
     fMenuStatus = FALSE;
     if ((HIWORD(lParam) & SYS_ALTERNATE) && wParam)
       {
         if (wParam == VK_TAB || wParam == VK_ESCAPE)
       break;

         /* Send ALT-SPACE only to top-level windows. */
         if ((wParam == MENUSYSMENU) && (TestwndChild(hwnd)))
       SendMessage(hwnd->hwndParent, message, wParam, lParam);
         else
       SendMessage(hwnd, WM_SYSCOMMAND, SC_KEYMENU, (DWORD)wParam);
       }
     else
         /* Ctrl-Esc produces a WM_SYSCHAR, But should not beep; */
         if(wParam != VK_ESCAPE)
             MessageBeep(0);
     break;

       case WM_CHARTOITEM:
       case WM_VKEYTOITEM:
           /* Do default processing for keystrokes into owner draw
              listboxes. */
           return(-1);


       case WM_ACTIVATE:
     if (wParam)
         SetFocus(hwnd);
     break;

       case WM_SETREDRAW:
     DWP_SetRedraw(hwnd, wParam);
     break;

       case WM_SHOWWINDOW:
     /* Non null descriptor implies popup hide or show. */
     /* We should check whether it is a popup window or Owned window */
     if (LOWORD(lParam) != 0 && (TestwndPopup(hwnd) || hwnd -> hwndOwner))
       {
         /* IF NOT(showing, invisible, and not set as hidden) AND
          *   NOT(hiding and not visible)
          */
         if (!(wParam != 0 && !TestWF(hwnd, WFVISIBLE) &&
       !TestWF(hwnd, WFHIDDENPOPUP)) &&
       !(wParam == 0 && !TestWF(hwnd, WFVISIBLE)))
     {
       /* Are we showing? */
       if (wParam)
           /* Yes, clear the hidden popup flag. */
           ClrWF(hwnd, WFHIDDENPOPUP);
       else
           /* No, Set the hidden popup flag. */
           SetWF(hwnd, WFHIDDENPOPUP);

       ShowWindow(hwnd,
            (wParam ? SHOW_OPENNOACTIVATE : HIDE_WINDOW));
     }
       }
     break;

       case WM_CTLCOLOR:
     if (HIWORD(lParam) != CTLCOLOR_SCROLLBAR)
       {
         SetBkColor((HDC)wParam, sysColors.clrWindow);
         SetTextColor((HDC)wParam, sysColors.clrWindowText);
         hbr = sysClrObjects.hbrWindow;
       }
     else
       {
               SetBkColor((HDC)wParam, 0x00ffffff);
               SetTextColor((HDC)wParam, (LONG)0x00000000);
         hbr = sysClrObjects.hbrScrollbar;
         UnrealizeObject(hbr);
       }

     return((DWORD)hbr);

       case WM_SETCURSOR:
     /* wParam  == hwnd that cursor is over
      * lParamL == Hit test area code (result of WM_NCHITTEST)
      * lParamH == Mouse message number
      */
     if (HIWORD(lParam) != 0 &&
         LOWORD(lParam) >= HTSIZEFIRST &&
         LOWORD(lParam) <= HTSIZELAST)
       {
         SetCursor(rghCursor[LOWORD(lParam) - HTSIZEFIRST + MVSIZEFIRST]);
         break;
       }

     if ((hwndT = GetChildParent(hwnd)) != NULL &&
            (BOOL)SendMessage(hwndT, WM_SETCURSOR, wParam, lParam))
         return((LONG)TRUE);

     if (HIWORD(lParam) == 0)
       {
         hCurs = hCursNormal;
         SetCursor(hCurs);
       }
     else
       {
         switch (LOWORD(lParam))
     {
       case HTCLIENT:
           if (((HWND)wParam)->pcls->hCursor != NULL)
         SetCursor(((HWND)wParam)->pcls->hCursor);
           break;

       case HTERROR:
           switch (HIWORD(lParam))
       {
         case WM_LBUTTONDOWN:
             if ((hwndT = DWP_GetEnabledPopup(hwnd)) != NULL)
         {
           if (hwndT != hwndDesktop->hwndChild)
             {
               SetWindowPos(hwnd, NULL,
                0, 0, 0, 0,
                SWP_NOMOVE | SWP_NOSIZE |
                SWP_NOACTIVATE);
               SetActiveWindow(hwndT);
               break;
             }
         }

             /*** FALL THRU ***/

         case WM_RBUTTONDOWN:
         case WM_MBUTTONDOWN:
                               MessageBeep(0);
             break;
       }
           /*** FALL THRU ***/

       default:
           SetCursor(hCursNormal);
     }
       }

     return((LONG)FALSE);

       case WM_MOUSEACTIVATE:
     if ((hwndT = GetChildParent(hwnd)) != NULL &&
         (i = (int)SendMessage(hwndT, WM_MOUSEACTIVATE, wParam, lParam))
           != 0)
         return((LONG)i);

     /* Moving, sizing or minimizing? Activate AFTER we take action. */
     if (LOWORD(lParam) == HTCAPTION)
         return((LONG)MA_NOACTIVATE);
     else
         return((LONG)MA_ACTIVATE);

       case WM_DRAWITEM:
           if (((LPDRAWITEMSTRUCT)lParam)->CtlType == ODT_LISTBOX)
               LBDefaultListboxDrawItem((LPDRAWITEMSTRUCT)lParam);
           break;

     }

   return(0L);
 }


 DEMO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SELECT\DEMO.C

 /****************************************************************************

     PROGRAM: Demo.c

     PURPOSE: Demonstrates how to manipulate a cursor and select a region

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   DemoInit() - initializes window data and registers window
   DemoWndProc() - processes messages
   About() - processes messages for "About" dialog box

     COMMENTS:
   This code is a modified version of the CURSOR.C program.  Instead of
   using inline code for drawing the shape, the routines from the Select
   library are called.

 ****************************************************************************/

 #include "windows.h"
 #include "demo.h"
 #include "select.h"

 HANDLE hInst;
 BOOL bTrack = FALSE;
 int OrgX = 0, OrgY = 0;
 int PrevX = 0, PrevY = 0;
 int X = 0, Y = 0;

 RECT Rect;

 int Shape = SL_BLOCK;             /* Shape to use for rectangle */
 BOOL RetainShape = FALSE;           /* Retain or destroy shape    */

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {

     HWND hWnd;
     MSG msg;

     if (!hPrevInstance)
   if (!DemoInit(hInstance))
       return (NULL);

     hInst = hInstance;

     hWnd = CreateWindow("Demo",
   "Demo Sample Application",
   WS_OVERLAPPEDWINDOW,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   NULL,
   NULL,
   hInstance,
   NULL);

     if (!hWnd)
   return (NULL);

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

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }

 /****************************************************************************

     FUNCTION: DemoInit(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL DemoInit(hInstance)
 HANDLE hInstance;
 {
     HANDLE hMemory;
     PWNDCLASS pWndClass;
     BOOL bSuccess;

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->lpszMenuName = (LPSTR) "Menu";
     pWndClass->lpszClassName = (LPSTR) "Demo";
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->hInstance = hInstance;
     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = DemoWndProc;

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);
     LocalFree(hMemory);
     return (bSuccess);
 }

 /****************************************************************************

     FUNCTION: DemoWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_SYSCOMMAND - system menu (About dialog box)
   WM_CREATE     - create window
   WM_DESTROY    - destroy window
   WM_LBUTTONDOWN - left mouse button
   WM_MOUSEMOVE   - mouse movement
   WM_LBUTTONUP   - left button released

   WM_COMMAND messages:
       IDM_BOX    - use inverted box for selecting a region
       IDM_BLOCK  - use empty box for selecting a region
       IDM_RETAIN - retain/delete selection on button release

     COMMENTS:

   When the left mouse button is pressed, btrack is set to TRUE so that
   the code for WM_MOUSEMOVE will keep track of the mouse and update the
   box accordingly.  Once the button is released, btrack is set to
   FALSE, and the current position is saved.  Holding the SHIFT key
   while pressing the left button will extend the current box rather
   then erasing it and starting a new one.   The exception is when the
   retain shape option is enabled.   With this option, the rectangle is
   zeroed whenever the mouse is released so that it can not be erased or
   extended.

 ****************************************************************************/

 long FAR PASCAL DemoWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;
     HMENU hMenu;

     switch (message) {

   case WM_COMMAND:
       switch (wParam) {
     case IDM_BOX:
         Shape = SL_BOX;
         hMenu = GetMenu(hWnd);
         CheckMenuItem(hMenu, IDM_BOX, MF_CHECKED);
         CheckMenuItem(hMenu, IDM_BLOCK, MF_UNCHECKED);
         break;

     case IDM_BLOCK:
         Shape = SL_BLOCK;
         hMenu = GetMenu(hWnd);
         CheckMenuItem(hMenu, IDM_BOX, MF_UNCHECKED);
         CheckMenuItem(hMenu, IDM_BLOCK, MF_CHECKED);
         break;

     case IDM_RETAIN:
         if (RetainShape) {
       hMenu = GetMenu(hWnd);
       CheckMenuItem(hMenu, IDM_RETAIN, MF_UNCHECKED);
       RetainShape = FALSE;
         }
         else {
       hMenu = GetMenu(hWnd);
       CheckMenuItem(hMenu, IDM_RETAIN, MF_CHECKED);
       RetainShape = TRUE;
         }
         break;

     case IDM_ABOUT:
         lpProcAbout = MakeProcInstance(About, hInst);
         DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
         FreeProcInstance(lpProcAbout);
         break;

       }
       break;

   case WM_LBUTTONDOWN:

       bTrack = TRUE;     /* user has pressed the left button */

       /* If you don't want the shape cleared, you must clear the Rect
        * coordinates before calling StartSelection
        */

       if (RetainShape)
     SetRectEmpty(&Rect);

       StartSelection(hWnd, MAKEPOINT(lParam), &Rect,
     (wParam & MK_SHIFT) ? SL_EXTEND | Shape : Shape);
       break;

   case WM_MOUSEMOVE:
       if (bTrack)
     UpdateSelection(hWnd, MAKEPOINT(lParam), &Rect, Shape);
       break;

   case WM_LBUTTONUP:
        if (bTrack)
          EndSelection(MAKEPOINT(lParam), &Rect);
       bTrack = FALSE;
       break;

    case WM_SIZE:
       switch (wParam) {
          case SIZEICONIC:

             /* If we aren't in retain mode we want to clear the
              * current rectangle now!
              */
             if (!RetainShape)
                SetRectEmpty(&Rect);
       }
       break;

   case WM_DESTROY:
       PostQuitMessage(NULL);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 DIB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\DIB.C

 /****************************************************************************
  *                         *
  *  MODULE  : DIB.C                    *
  *                         *
  *  DESCRIPTION : Routines for dealing with Device Independent Bitmaps.
  *                         *
  *  FUNCTIONS  : OpenDIB()        - Opens DIB file and creates a memory DIB*
  *                         *
  *      WriteDIB()        - Writes a global handle in CF_DIB format*
  *          to a file.             *
  *                         *
  *      DibInfo()        - Retrieves the info. block associated   *
  *          with a CF_DIB format memory block.     *
  *                         *
  *      CreateBIPalette()   - Creates a GDI palette given a pointer  *
  *          to a BITMAPINFO structure.         *
  *                         *
  *      CreateDibPalette()  - Creates a GDI palette given a HANDLE   *
  *          to a BITMAPINFO structure.         *
  *                         *
  *      ReadDibBitmapInfo() - Reads a file in DIB format and returns *
  *          a global handle to it's BITMAPINFO     *
  *                         *
  *      PaletteSize()       - Calculates the palette size in bytes   *
  *          of given DIB             *
  *                         *
  *      DibNumColors()      - Determines the number of colors in DIB *
  *                         *
  *      BitmapFromDib()     - Creates a DDB given a global handle to *
  *          a block in CF_DIB format.         *
  *                         *
  *      DibFromBitmap()     - Creates a DIB repr. the DDB passed in. *
  *                         *
  *      DrawBitmap()        - Draws a bitmap at specified position   *
  *          in the DC.             *
  *                         *
  *      DibBlt()        - Draws a bitmap in CIF_DIB format using *
  *          SetDIBitsToDevice()           *
  *                         *
  *      StretchDibBlt()     - Draws a bitmap in CIF_DIB format using *
  *          StretchDIBits()            *
  *                         *
  *      lread()        - Private routine to read more than 64k  *
  *                         *
  *      lwrite()        - Private routine to write more than 64k *
  *                         *
  ****************************************************************************

 #include <windows.h>
 #include "showdib.h"
 static   HCURSOR hcurSave;

 /****************************************************************************
  *                      *
  *  FUNCTION   :OpenDIB(LPSTR szFile)              *
  *                      *
  *  PURPOSE    :Open a DIB file and create a MEMORY DIB, a memory handle    *
  *    containing BITMAPINFO, palette data and the bits.      *
  *                      *
  *  RETURNS    :A handle to the DIB.              *
  *                      *
  ****************************************************************************
 HANDLE OpenDIB (szFile)
 LPSTR szFile;
 {
     unsigned    fh;
     BITMAPINFOHEADER  bi;
     LPBITMAPINFOHEADER  lpbi;
     DWORD    dwLen = 0;
     DWORD    dwBits;
     HANDLE    hdib;
     HANDLE              h;
     OFSTRUCT    of;

     /* Open the file and read the DIB information */
     fh = OpenFile(szFile, &of, OF_READ);
     if (fh == -1)
   return NULL;

     hdib = ReadDibBitmapInfo(fh);
     if (!hdib)
   return NULL;
     DibInfo(hdib,&bi);

     /* Calculate the memory needed to hold the DIB */
     dwBits = bi.biSizeImage;
     dwLen  = bi.biSize + (DWORD)PaletteSize (&bi) + dwBits;

     /* Try to increase the size of the bitmap info. buffer to hold the DIB */
     h = GlobalReAlloc(hdib, dwLen, GHND);
     if (!h){
   GlobalFree(hdib);
   hdib = NULL;
     }
     else
   hdib = h;

     /* Read in the bits */
     if (hdib){

         lpbi = (VOID FAR *)GlobalLock(hdib);
   lread(fh, (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi), dwBits);
   GlobalUnlock(hdib);
     }
     _lclose(fh);

     return hdib;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : WriteDIB(LPSTR szFile,HANDLE hdib)          *
  *                      *
  *  PURPOSE    : Write a global handle in CF_DIB format to a file.      *
  *                      *
  *  RETURNS    : TRUE  - if successful.             *
  *     FALSE - otherwise              *
  *                      *
  ****************************************************************************
 BOOL WriteDIB (szFile, hdib)
 LPSTR szFile;
 HANDLE hdib;
 {
     BITMAPFILEHEADER  hdr;
     LPBITMAPINFOHEADER  lpbi;
     int                 fh;
     OFSTRUCT            of;

     if (!hdib)
   return FALSE;

     fh = OpenFile (szFile, &of, OF_CREATE|OF_READWRITE);
     if (fh == -1)
   return FALSE;

     lpbi = (VOID FAR *)GlobalLock (hdib);

     /* Fill in the fields of the file header */
     hdr.bfType    = BFT_BITMAP;
     hdr.bfSize    = GlobalSize (hdib) + sizeof (BITMAPFILEHEADER);
     hdr.bfReserved1     = 0;
     hdr.bfReserved2     = 0;
     hdr.bfOffBits       = (DWORD)sizeof(BITMAPFILEHEADER) + lpbi->biSize +
                           PaletteSize(lpbi);

     /* Write the file header */
     _lwrite (fh, (LPSTR)&hdr, sizeof (BITMAPFILEHEADER));

     /* Write the DIB header and the bits */
     lwrite (fh, (LPSTR)lpbi, GlobalSize (hdib));

     GlobalUnlock (hdib);
     _lclose (fh);
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : DibInfo(HANDLE hbi,LPBITMAPINFOHEADER lpbi)        *
  *                      *
  *  PURPOSE    : Retrieves the DIB info associated with a CF_DIB      *
  *     format memory block.              *
  *                      *
  *  RETURNS    : TRUE  - if successful.             *
  *     FALSE - otherwise              *
  *                      *
  ****************************************************************************
 BOOL DibInfo (hbi, lpbi)
 HANDLE hbi;
 LPBITMAPINFOHEADER lpbi;
 {
     if (hbi){
   *lpbi = *(LPBITMAPINFOHEADER)GlobalLock (hbi);

   /* fill in the default fields */
   if (lpbi->biSize != sizeof (BITMAPCOREHEADER)){
             if (lpbi->biSizeImage == 0L)
     lpbi->biSizeImage =
         WIDTHBYTES(lpbi->biWidth*lpbi->biBitCount) * lpbi->biHeight;

             if (lpbi->biClrUsed == 0L)
     lpbi->biClrUsed = DibNumColors (lpbi);
         }
   GlobalUnlock (hbi);
   return TRUE;
     }
     return FALSE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : CreateBIPalette(LPBITMAPINFOHEADER lpbi)        *
  *                      *
  *  PURPOSE    : Given a Pointer to a BITMAPINFO struct will create a      *
  *     a GDI palette object from the color table.        *
  *                      *
  *  RETURNS    : A handle to the palette.            *
  *                      *
  ****************************************************************************
 HPALETTE CreateBIPalette (lpbi)
 LPBITMAPINFOHEADER lpbi;
 {
     LOGPALETTE          *pPal;
     HPALETTE            hpal = NULL;
     WORD                nNumColors;
     BYTE                red;
     BYTE                green;
     BYTE                blue;
     int                 i;
     RGBQUAD        FAR *pRgb;

     if (!lpbi)
   return NULL;

     if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
   return NULL;

     /* Get a pointer to the color table and the number of colors in it */
     pRgb = (RGBQUAD FAR *)((LPSTR)lpbi + (WORD)lpbi->biSize);
     nNumColors = DibNumColors(lpbi);

     if (nNumColors){
   /* Allocate for the logical palette structure */
         pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors *
   if (!pPal)
       return NULL;

         pPal->palNumEntries = nNumColors;
   pPal->palVersion    = PALVERSION;

   /* Fill in the palette entries from the DIB color table and
    * create a logical color palette.
    */
   for (i = 0; i < nNumColors; i++){
             pPal->palPalEntry[i].peRed   = pRgb[i].rgbRed;
             pPal->palPalEntry[i].peGreen = pRgb[i].rgbGreen;
             pPal->palPalEntry[i].peBlue  = pRgb[i].rgbBlue;
             pPal->palPalEntry[i].peFlags = (BYTE)0;
         }
         hpal = CreatePalette(pPal);
         LocalFree((HANDLE)pPal);
     }
     else if (lpbi->biBitCount == 24){
   /* A 24 bitcount DIB has no color table entries so, set the number of
    * to the maximum value (256).
    */
   nNumColors = MAXPALETTE;
         pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors *
         if (!pPal)
       return NULL;

   pPal->palNumEntries = nNumColors;
   pPal->palVersion    = PALVERSION;

   red = green = blue = 0;

   /* Generate 256 (= 8*8*4) RGB combinations to fill the palette
    * entries.
    */
   for (i = 0; i < pPal->palNumEntries; i++){
             pPal->palPalEntry[i].peRed   = red;
             pPal->palPalEntry[i].peGreen = green;
             pPal->palPalEntry[i].peBlue  = blue;
             pPal->palPalEntry[i].peFlags = (BYTE)0;

       if (!(red += 32))
     if (!(green += 32))
         blue += 64;
         }
         hpal = CreatePalette(pPal);
         LocalFree((HANDLE)pPal);
     }
     return hpal;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : CreateDibPalette(HANDLE hbi)            *
  *                      *
  *  PURPOSE    : Given a Global HANDLE to a BITMAPINFO Struct        *
  *     will create a GDI palette object from the color table.     *
  *     (BITMAPINFOHEADER format DIBs only)           *
  *                      *
  *  RETURNS    : A handle to the palette.            *
  *                      *
  ****************************************************************************
 HPALETTE CreateDibPalette (hbi)
 HANDLE hbi;
 {
     HPALETTE hpal;

     if (!hbi)
   return NULL;
     hpal = CreateBIPalette((LPBITMAPINFOHEADER)GlobalLock(hbi));
     GlobalUnlock(hbi);
     return hpal;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : ReadDibBitmapInfo(int fh)            *
  *                      *
  *  PURPOSE    : Will read a file in DIB format and return a global HANDLE  *
  *     to it's BITMAPINFO.  This function will work with both     *
  *     "old" (BITMAPCOREHEADER) and "new" (BITMAPINFOHEADER)      *
  *     bitmap formats, but will always return a "new" BITMAPINFO  *
  *                      *
  *  RETURNS    : A handle to the BITMAPINFO of the DIB in the file.      *
  *                      *
  ****************************************************************************
 HANDLE ReadDibBitmapInfo (fh)
 int fh;
 {
     DWORD     off;
     HANDLE    hbi = NULL;
     int       size;
     int       i;
     WORD      nNumColors;

     RGBQUAD FAR       *pRgb;
     BITMAPINFOHEADER   bi;
     BITMAPCOREHEADER   bc;
     LPBITMAPINFOHEADER lpbi;
     BITMAPFILEHEADER   bf;
     DWORD         dwWidth = 0;
     DWORD         dwHeight = 0;
     WORD         wPlanes, wBitCount;

     if (fh == -1)
         return NULL;

     /* Reset file pointer and read file header */
     off = _llseek(fh, 0L, SEEK_CUR);
     if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
         return FALSE;

     /* Do we have a RC HEADER? */
     if (!ISDIB (bf.bfType)) {
         bf.bfOffBits = 0L;
   _llseek (fh, off, SEEK_SET);
     }
     if (sizeof (bi) != _lread (fh, (LPSTR)&bi, sizeof(bi)))
         return FALSE;

     nNumColors = DibNumColors (&bi);

     /* Check the nature (BITMAPINFO or BITMAPCORE) of the info. block
      * and extract the field information accordingly. If a BITMAPCOREHEADER,
      * transfer it's field information to a BITMAPINFOHEADER-style block
      */
     switch (size = (int)bi.biSize){
   case sizeof (BITMAPINFOHEADER):
             break;

   case sizeof (BITMAPCOREHEADER):

       bc = *(BITMAPCOREHEADER*)&bi;

       dwWidth   = (DWORD)bc.bcWidth;
       dwHeight  = (DWORD)bc.bcHeight;
       wPlanes   = bc.bcPlanes;
       wBitCount = bc.bcBitCount;

             bi.biSize               = sizeof(BITMAPINFOHEADER);
       bi.biWidth        = dwWidth;
       bi.biHeight       = dwHeight;
       bi.biPlanes       = wPlanes;
       bi.biBitCount      = wBitCount;

             bi.biCompression        = BI_RGB;
             bi.biSizeImage          = 0;
             bi.biXPelsPerMeter      = 0;
             bi.biYPelsPerMeter      = 0;
             bi.biClrUsed            = nNumColors;
             bi.biClrImportant       = nNumColors;

       _llseek (fh, (LONG)sizeof (BITMAPCOREHEADER) - sizeof (BITMAPINFOHEADER
             break;

   default:
       /* Not a DIB! */
       return NULL;
     }

     /*  Fill in some default values if they are zero */
     if (bi.biSizeImage == 0){
   bi.biSizeImage = WIDTHBYTES ((DWORD)bi.biWidth * bi.biBitCount)
        * bi.biHeight;
     }
     if (bi.biClrUsed == 0)
   bi.biClrUsed = DibNumColors(&bi);

     /* Allocate for the BITMAPINFO structure and the color table. */
     hbi = GlobalAlloc (GHND, (LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));
     if (!hbi)
         return NULL;
     lpbi = (VOID FAR *)GlobalLock (hbi);
     *lpbi = bi;

     /* Get a pointer to the color table */
     pRgb = (RGBQUAD FAR *)((LPSTR)lpbi + bi.biSize);
     if (nNumColors){
   if (size == sizeof(BITMAPCOREHEADER)){
       /* Convert a old color table (3 byte RGBTRIPLEs) to a new
        * color table (4 byte RGBQUADs)
              */
       _lread (fh, (LPSTR)pRgb, nNumColors * sizeof(RGBTRIPLE));

       for (i = nNumColors - 1; i >= 0; i--){
                 RGBQUAD rgb;

                 rgb.rgbRed      = ((RGBTRIPLE FAR *)pRgb)[i].rgbtRed;
                 rgb.rgbBlue     = ((RGBTRIPLE FAR *)pRgb)[i].rgbtBlue;
                 rgb.rgbGreen    = ((RGBTRIPLE FAR *)pRgb)[i].rgbtGreen;
                 rgb.rgbReserved = (BYTE)0;

                 pRgb[i] = rgb;
             }
         }
   else
             _lread(fh,(LPSTR)pRgb,nNumColors * sizeof(RGBQUAD));
     }

     if (bf.bfOffBits != 0L)
         _llseek(fh,off + bf.bfOffBits,SEEK_SET);

     GlobalUnlock(hbi);
     return hbi;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   :  PaletteSize(VOID FAR * pv)            *
  *                      *
  *  PURPOSE    :  Calculates the palette size in bytes. If the info. block  *
  *      is of the BITMAPCOREHEADER type, the number of colors is  *
  *      multiplied by 3 to give the palette size, otherwise the   *
  *      number of colors is multiplied by 4.                *
  *                      *
  *  RETURNS    :  Palette size in number of bytes.          *
  *                      *
  ****************************************************************************
 WORD PaletteSize (pv)
 VOID FAR * pv;
 {
     LPBITMAPINFOHEADER lpbi;
     WORD         NumColors;

     lpbi      = (LPBITMAPINFOHEADER)pv;
     NumColors = DibNumColors(lpbi);

     if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
         return NumColors * sizeof(RGBTRIPLE);
     else
         return NumColors * sizeof(RGBQUAD);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : DibNumColors(VOID FAR * pv)            *
  *                      *
  *  PURPOSE    : Determines the number of colors in the DIB by looking at   *
  *     the BitCount filed in the info block.          *
  *                      *
  *  RETURNS    : The number of colors in the DIB.          *
  *                      *
  ****************************************************************************
 WORD DibNumColors (pv)
 VOID FAR * pv;
 {
     int     bits;
     LPBITMAPINFOHEADER  lpbi;
     LPBITMAPCOREHEADER  lpbc;

     lpbi = ((LPBITMAPINFOHEADER)pv);
     lpbc = ((LPBITMAPCOREHEADER)pv);

     /*  With the BITMAPINFO format headers, the size of the palette
      *  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
      *  is dependent on the bits per pixel ( = 2 raised to the power of
      *  bits/pixel).
      */
     if (lpbi->biSize != sizeof(BITMAPCOREHEADER)){
         if (lpbi->biClrUsed != 0)
             return (WORD)lpbi->biClrUsed;
         bits = lpbi->biBitCount;
     }
     else
         bits = lpbc->bcBitCount;

     switch (bits){
   case 1:
     return 2;
   case 4:
     return 16;
   case 8:
     return 256;
   default:
     /* A 24 bitcount DIB has no color table */
     return 0;
     }
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : DibFromBitmap()              *
  *                      *
  *  PURPOSE    : Will create a global memory block in DIB format that      *
  *     represents the Device-dependent bitmap (DDB) passed in.    *
  *                      *
  *  RETURNS    : A handle to the DIB              *
  *                      *
  ****************************************************************************
 HANDLE DibFromBitmap (hbm, biStyle, biBits, hpal)
 HBITMAP      hbm;
 DWORD       biStyle;
 WORD       biBits;
 HPALETTE     hpal;
 {
     BITMAP               bm;
     BITMAPINFOHEADER     bi;
     BITMAPINFOHEADER FAR *lpbi;
     DWORD                dwLen;
     HANDLE               hdib;
     HANDLE               h;
     HDC                  hdc;

     if (!hbm)
   return NULL;

     if (hpal == NULL)
         hpal = GetStockObject(DEFAULT_PALETTE);

     GetObject(hbm,sizeof(bm),(LPSTR)&bm);

     if (biBits == 0)
   biBits =  bm.bmPlanes * bm.bmBitsPixel;

     bi.biSize               = sizeof(BITMAPINFOHEADER);
     bi.biWidth              = bm.bmWidth;
     bi.biHeight             = bm.bmHeight;
     bi.biPlanes             = 1;
     bi.biBitCount           = biBits;
     bi.biCompression        = biStyle;
     bi.biSizeImage          = 0;
     bi.biXPelsPerMeter      = 0;
     bi.biYPelsPerMeter      = 0;
     bi.biClrUsed            = 0;
     bi.biClrImportant       = 0;

     dwLen  = bi.biSize + PaletteSize(&bi);

     hdc = GetDC(NULL);
     hpal = SelectPalette(hdc,hpal,FALSE);
    RealizePalette(hdc);

     hdib = GlobalAlloc(GHND,dwLen);

     if (!hdib){
   SelectPalette(hdc,hpal,FALSE);
   ReleaseDC(NULL,hdc);
   return NULL;
     }

     lpbi = (VOID FAR *)GlobalLock(hdib);

     *lpbi = bi;

     /*  call GetDIBits with a NULL lpBits param, so it will calculate the
      *  biSizeImage field for us
      */
     GetDIBits(hdc, hbm, 0, (WORD)bi.biHeight,
         NULL, (LPBITMAPINFO)lpbi, DIB_RGB_COLORS);

     bi = *lpbi;
     GlobalUnlock(hdib);

     /* If the driver did not fill in the biSizeImage field, make one up */
     if (bi.biSizeImage == 0){
         bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight

         if (biStyle != BI_RGB)
             bi.biSizeImage = (bi.biSizeImage * 3) / 2;
     }

     /*  realloc the buffer big enough to hold all the bits */
     dwLen = bi.biSize + PaletteSize(&bi) + bi.biSizeImage;
     if (h = GlobalReAlloc(hdib,dwLen,0))
         hdib = h;
     else{
         GlobalFree(hdib);
   hdib = NULL;

   SelectPalette(hdc,hpal,FALSE);
   ReleaseDC(NULL,hdc);
   return hdib;
     }

     /*  call GetDIBits with a NON-NULL lpBits param, and actualy get the
      *  bits this time
      */
     lpbi = (VOID FAR *)GlobalLock(hdib);

     if (GetDIBits( hdc,
        hbm,
        0,
        (WORD)bi.biHeight,
        (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi),
        (LPBITMAPINFO)lpbi, DIB_RGB_COLORS) == 0){
    GlobalUnlock(hdib);
    hdib = NULL;
    SelectPalette(hdc,hpal,FALSE);
    ReleaseDC(NULL,hdc);
    return NULL;
     }

     bi = *lpbi;
     GlobalUnlock(hdib);

     SelectPalette(hdc,hpal,FALSE);
     ReleaseDC(NULL,hdc);
     return hdib;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : BitmapFromDib(HANDLE hdib, HPALETTE hpal)        *
  *                      *
  *  PURPOSE    : Will create a DDB (Device Dependent Bitmap) given a global *
  *     handle to a memory block in CF_DIB format        *
  *                      *
  *  RETURNS    : A handle to the DDB.              *
  *                      *
  ****************************************************************************
 HBITMAP BitmapFromDib (hdib, hpal)
 HANDLE     hdib;
 HPALETTE   hpal;
 {
     LPBITMAPINFOHEADER  lpbi;
     HPALETTE    hpalT;
     HDC     hdc;
     HBITMAP    hbm;

     StartWait();

     if (!hdib)
   return NULL;

     lpbi = (VOID FAR *)GlobalLock(hdib);

     if (!lpbi)
   return NULL;

     hdc = GetDC(NULL);

     if (hpal){
         hpalT = SelectPalette(hdc,hpal,FALSE);
         RealizePalette(hdc);     // GDI Bug...????
     }

     hbm = CreateDIBitmap(hdc,
                 (LPBITMAPINFOHEADER)lpbi,
                 (LONG)CBM_INIT,
                 (LPSTR)lpbi + lpbi->biSize + PaletteSize(lpbi),
                 (LPBITMAPINFO)lpbi,
                 DIB_RGB_COLORS );

     if (hpal)
         SelectPalette(hdc,hpalT,FALSE);

     ReleaseDC(NULL,hdc);
     GlobalUnlock(hdib);

     EndWait();

     return hbm;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : DrawBitmap(HDC hdc, int x, int y, HBITMAP hbm, DWORD rop)  *
  *                      *
  *  PURPOSE    : Draws bitmap <hbm> at the specifed position in DC <hdc>    *
  *                      *
  *  RETURNS    : Return value of BitBlt()            *
  *                      *
  ****************************************************************************
 BOOL DrawBitmap (hdc, x, y, hbm, rop)
 HDC     hdc;
 int     x, y;
 HBITMAP    hbm;
 DWORD     rop;
 {
     HDC       hdcBits;
     BITMAP    bm;
     HPALETTE  hpalT;
     BOOL      f;

     if (!hdc || !hbm)
         return FALSE;

     hdcBits = CreateCompatibleDC(hdc);
     GetObject(hbm,sizeof(BITMAP),(LPSTR)&bm);
     SelectObject(hdcBits,hbm);
     f = BitBlt(hdc,0,0,bm.bmWidth,bm.bmHeight,hdcBits,0,0,rop);
     DeleteDC(hdcBits);

     return f;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : DibBlt( HDC hdc,              *
  *       int x0, int y0,            *
  *       int dx, int dy,            *
  *       HANDLE hdib,              *
  *       int x1, int y1,            *
  *       LONG rop)              *
  *                      *
  *  PURPOSE    : Draws a bitmap in CF_DIB format, using SetDIBits to device.*
  *     taking the same parameters as BitBlt().        *
  *                      *
  *  RETURNS    : TRUE  - if function succeeds.            *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 BOOL DibBlt (hdc, x0, y0, dx, dy, hdib, x1, y1, rop)
 HDC     hdc;
 int     x0, y0, dx, dy;
 HANDLE     hdib;
 int     x1, y1;
 LONG     rop;
 {
     LPBITMAPINFOHEADER   lpbi;
     HPALETTE     hpal,hpalT;
     LPSTR     pBuf;
     HDC      hdcMem;
     HBITMAP     hbm,hbmT;

     if (!hdib)
   return PatBlt(hdc,x0,y0,dx,dy,rop);

     lpbi = (VOID FAR *)GlobalLock(hdib);

     if (!lpbi)
   return FALSE;

     pBuf = (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi);
     SetDIBitsToDevice (hdc, x0, y0, dx, dy,
            x1,y1,
            x1,
            dy,
            pBuf, (LPBITMAPINFO)lpbi,
            DIB_RGB_COLORS );

     GlobalUnlock(hdib);
     return TRUE;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : StretchDibBlt( HDC hdc,            *
  *        int x, int y,            *
  *        int dx, int dy,           *
  *        HANDLE hdib,            *
  *        int x0, int y0,           *
  *        int dx0, int dy0,          *
  *        LONG rop)            *
  *                      *
  *  PURPOSE    : Draws a bitmap in CF_DIB format, using StretchDIBits()     *
  *     taking the same parameters as StretchBlt().        *
  *                      *
  *  RETURNS    : TRUE  - if function succeeds.            *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 BOOL StretchDibBlt (hdc, x, y, dx, dy, hdib, x0, y0, dx0, dy0, rop)
 HDC hdc;
 int x, y;
 int dx, dy;
 HANDLE hdib;
 int x0, y0;
 int dx0, dy0;
 LONG rop;

 {
     LPBITMAPINFOHEADER lpbi;
     LPSTR        pBuf;
     BOOL         f;

     if (!hdib)
         return PatBlt(hdc,x,y,dx,dy,rop);

     lpbi = (VOID FAR *)GlobalLock(hdib);

     if (!lpbi)
         return FALSE;

     pBuf = (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi);

     f = StretchDIBits ( hdc,
       x, y,
       dx, dy,
       x0, y0,
       dx0, dy0,
       pBuf, (LPBITMAPINFO)lpbi,
       DIB_RGB_COLORS,
       rop);

     GlobalUnlock(hdib);
     return f;
 }

  /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
 /****************************************************************************
  *                      *
  *  FUNCTION   : lread(int fh, VOID FAR *pv, DWORD ul)          *
  *                      *
  *  PURPOSE    : Reads data in steps of 32k till all the data has been read.*
  *                      *
  *  RETURNS    : 0 - If read did not proceed correctly.         *
  *     number of bytes read otherwise.          *
  *                      *
  ****************************************************************************
 DWORD PASCAL lread (fh, pv, ul)
 int        fh;
 VOID far      *pv;
 DWORD        ul;
 {
     DWORD     ulT = ul;
     BYTE huge *hp = pv;

     while (ul > (DWORD)MAXREAD) {
   if (_lread(fh, (LPSTR)hp, (WORD)MAXREAD) != MAXREAD)
     return 0;
   ul -= MAXREAD;
   hp += MAXREAD;
     }
     if (_lread(fh, (LPSTR)hp, (WORD)ul) != (WORD)ul)
   return 0;
     return ulT;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : lwrite(int fh, VOID FAR *pv, DWORD ul)         *
  *                      *
  *  PURPOSE    : Writes data in steps of 32k till all the data is written.  *
  *                      *
  *  RETURNS    : 0 - If write did not proceed correctly.        *
  *     number of bytes written otherwise.          *
  *                      *
  ****************************************************************************
 DWORD PASCAL lwrite (fh, pv, ul)
 int       fh;
 VOID FAR     *pv;
 DWORD       ul;
 {
     DWORD     ulT = ul;
     BYTE huge *hp = pv;

     while (ul > MAXREAD) {
   if (_lwrite(fh, (LPSTR)hp, (WORD)MAXREAD) != MAXREAD)
     return 0;
   ul -= MAXREAD;
   hp += MAXREAD;
     }
     if (_lwrite(fh, (LPSTR)hp, (WORD)ul) != (WORD)ul)
   return 0;
     return ulT;
 }


 DLGOPEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\DLGOPEN.C

 /****************************************************************************
  *                         *
  *  MODULE  : DLGOPEN.C                   *
  *                         *
  *  DESCRIPTION : Routines to display a standard File/Open and File/Save
  *      dialog boxes.                  *
  *                         *
  *  FUNCTIONS  : DlgOpenFile() - Displays a dialog box for opening or saving
  *          file.                *
  *                         *
  *      DlgfnOpen()  - Dialog function for the above dialog.        *
  *                         *
  *      AddExt()  - Adds an extension to a filename if not       *
  *          already present.             *
  *                         *
  *      FSearchSpec() - Checks if given string contains a wildcard   *
  *          character.               *
  *                         *
  *      FillListBox() - Fills listbox with files that match specs.   *
  *                         *
  *      DlgCheckOkEnable() - Enables <OK> button iff there's text in *
  *               the edit control.           *
  *                         *
  *      NOTE : These routines require that the app. be running       *
  *       SS = DS since they use near pointers into the stack.  *
  *                         *
  ****************************************************************************
 #include <windows.h>
 #include "showdib.h"

 static PSTR         szExt;
 static PSTR         szFileName;
 static PSTR         szTitle;
 static DWORD        flags;
 static WORD         fOpt;

 /* Forward declarations of helper functions */

 static void  NEAR DlgCheckOkEnable(HWND hwnd, int idEdit, unsigned message);
 static char *NEAR FillListBox (HWND,char*);
 static BOOL  NEAR FSearchSpec (char*);
 static void  NEAR AddExt (char*,char*);
 extern PASCAL chdir(LPSTR);     /* in dlgopena.asm */

 #define DLGOPEN_UNUSED   0

 /* Mask to eliminate bogus style and bitcount combinations ...
  * RLE formats, if chosen should be matched with the bitcounts:
  *   RLE4 scheme should be used only for 4 bitcount DIBs.
  *   RLE8   "      "   "   "   "    "  8   "       "
  *
  * BITCOUNTMASK is indexed by DLGOPEN_RLE4 >> 4, DLGOPEN_RLE8 >> 4
  * and DLGOPEN_RLE8 >> 4
  */

 static WORD BITCOUNTMASK[] = { DLGOPEN_UNUSED,
              DLGOPEN_1BPP | DLGOPEN_8BPP | DLGOPEN_24BPP,
              DLGOPEN_1BPP | DLGOPEN_4BPP | DLGOPEN_24BPP,
              DLGOPEN_UNUSED,
              0 };

 /****************************************************************************
  *                         *
  *  FUNCTION   :DlgOpen(LPSTR szFile)                 *
  *                         *
  *  PURPOSE    :Display dialog box for opening files. Allow user to interact
  *    with dialogbox, change directories as necessary, and try to    *
  *    open file if user selects one. Automatically append         *
  *    extension to filename if necessary.             *
  *    This routine correctly parses filenames containing KANJI       *
  *    characters.                   *
  *                         *
  *  RETURNS    :  - Handle to the opened file if legal filename.         *
  *      - 0 if user presses <cancel>               *
  *      - 1 if filename entered is illegal             *
  *                         *
  ****************************************************************************
 int FAR PASCAL DlgOpenFile (hwndParent, szTitleIn, flagsIn, szExtIn,
           szFileNameIn, pfOpt)

 HWND    hwndParent;
 char    *szTitleIn;
 DWORD    flagsIn;
 char    *szExtIn;
 char    *szFileNameIn;
 WORD    *pfOpt;
 {
     int      fh;
     FARPROC  lpProc;
     char     achFile[128];
     char     achExt[128];
     HANDLE   hInstance;
     WORD     w;

     if (pfOpt == NULL)
         pfOpt = &w;

     flags    = flagsIn;
     fOpt     = *pfOpt;

     lstrcpy (szFileName = achFile, szFileNameIn);
     lstrcpy (szExt = achExt, szExtIn);
     szTitle = szTitleIn;

     hInstance = GetWindowWord (hwndParent, GWW_HINSTANCE);

     /* Show the dialog box */
     lpProc = MakeProcInstance ((FARPROC)DlgfnOpen, hInstance);
     fh = DialogBox (hInstance, "DlgOpenBox", hwndParent, lpProc);
     FreeProcInstance (lpProc);

     if (fh != 0){
   lstrcpy (szFileNameIn, szFileName);
         *pfOpt = fOpt;
     }
     return fh;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   :DlgfnOpen (hwnd, msg, wParam, lParam)          *
  *                      *
  *  PURPOSE    :Dialog function for File/Open dialog.          *
  *                      *
  ****************************************************************************
 int far PASCAL DlgfnOpen (hwnd, msg, wParam, lParam)

 HWND hwnd;
 unsigned msg;
 WORD wParam;
 LONG lParam;
 {
     int      result = -1;    /* Assume illegal filename initially */
     WORD     w;
     char     c;
     WORD     f;
     OFSTRUCT of;
     RECT     rc, rcCtl;
     HWND     hwndT;
     BOOL     fEnable;

     switch (msg) {
   case WM_INITDIALOG:
       if (szTitle && *szTitle)
     SetWindowText (hwnd, szTitle);

       /* Set text on <OK> button according to mode (File/Open or File/Save) *
       if (flags & OF_SAVE)
     SetDlgItemText (hwnd, IDOK, "&Save");
       if (flags & OF_OPEN)
     SetDlgItemText (hwnd, IDOK, "&Open");

       if ((flags & OF_NOOPTIONS) &&
     (hwndT = GetDlgItem(hwnd,DLGOPEN_FOLDOUT)))
     EnableWindow (hwndT,FALSE);

       if (hwndT = GetDlgItem (hwnd, DLGOPEN_SMALL)) {
     GetWindowRect (hwnd,&rc);
     GetWindowRect (GetDlgItem(hwnd,DLGOPEN_SMALL),&rcCtl);

     SetWindowPos (hwnd,
             NULL,
             0,
             0,
             rcCtl.left - rc.left,
             rc.bottom - rc.top,
             SWP_NOZORDER | SWP_NOMOVE);
       }
       /* fill list box with filenames that match specifications, and
        * fill static field with path name.
        */
       FillListBox(hwnd,szExt);

       /* If in Save mode, set the edit control with default (current)
        * file name,and select the corresponding entry in the listbox.
        */
       if ((flags & OF_SAVE) && *szFileName) {
     SetDlgItemText (hwnd, DLGOPEN_EDIT, szFileName);
     SendDlgItemMessage (hwnd,
             DLGOPEN_FILE_LISTBOX,
             LB_SELECTSTRING,
             0,
             (LONG)(LPSTR)szFileName);
       }
       else {
     /*  Set the edit field with the default extensions... */
     if (flags & OF_NOSHOWSPEC)
         SetDlgItemText (hwnd, DLGOPEN_EDIT, "");
     else
         SetDlgItemText (hwnd, DLGOPEN_EDIT, szExt);
       }
       /*  ...and select all text in the edit field */
       SendDlgItemMessage (hwnd, DLGOPEN_EDIT, EM_SETSEL, 0, 0x7FFF0000L);

       /*  check all options that are set */
       for ( f = DLGOPEN_1BPP; f; f<<=1)
     CheckDlgButton(hwnd, FID(f), fOpt & f);

       break;

   case WM_COMMAND:
       w = wParam;
       switch (w) {
     case IDOK:
         if (IsWindowEnabled (GetDlgItem(hwnd, IDOK))) {
       /* Get contents of edit field and add search spec. if it
        * does not contain one.
        */
       GetDlgItemText (hwnd, DLGOPEN_EDIT, (LPSTR)szFileName, 128);

       w = lstrlen(szFileName)-1;
       c = szFileName[w];
       switch (c) {
           case '\\':
           case '/':
         szFileName[w] = 0;
         break;
       }
       if (chdir ((LPSTR)szFileName))
           lstrcpy (szFileName,szExt);

       /*  Try to open path.  If successful, fill listbox with
        *  contents of new directory.  Otherwise, open datafile.
        */
       if (FSearchSpec(szFileName)) {
           lstrcpy (szExt, FillListBox (hwnd, szFileName));
           if (flags & OF_NOSHOWSPEC)
         SetDlgItemText (hwnd, DLGOPEN_EDIT, "");
           else
         SetDlgItemText (hwnd, DLGOPEN_EDIT, szExt);
           break;
       }

       /*  Make filename upper case and if it's a legal DOS
        *  name, try to open the file.
        */
       AnsiUpper(szFileName);
       AddExt(szFileName,szExt);
       result = OpenFile(szFileName, &of, (WORD)flags);

       if (result != -1) {
           lstrcpy(szFileName,of.szPathName);
       }
       else if (flags & OF_MUSTEXIST) {
           MessageBeep(0);
           return 0L;
       }

       /*  Get the state of all checked options */
       for (f = DLGOPEN_1BPP; f; f <<= 1){
           if (IsDlgButtonChecked (hwnd, FID (f)))
         fOpt |= f;
           else
         fOpt &= ~f;
       }

       EndDialog (hwnd, result);
         }
         break;

     case DLGOPEN_OPTION + DLGOPEN_RLE4:
     case DLGOPEN_OPTION + DLGOPEN_RLE8:
     case DLGOPEN_OPTION + DLGOPEN_RGB:
         /* Mask out incompatible bitcount options and gray the
          * appropriate radiobuttons.
          */
         for (f = DLGOPEN_1BPP; f <= DLGOPEN_24BPP; f <<= 1){
       fEnable = !(f & BITCOUNTMASK [IDF(w) >> 4 ]);
       EnableWindow (GetDlgItem (hwnd, FID(f)), fEnable);

       /* If the radiobutton is being grayed, uncheck it and
        * and check an "allowed" option so the bitcount group
        * is still accessible via the keyboard
        */
       if (!fEnable && IsDlgButtonChecked (hwnd, FID (f))){
           CheckDlgButton(hwnd, FID(f), FALSE);
           CheckDlgButton(hwnd, FID(IDF(w) >> 3), TRUE);
       }
         }
         break;

     case IDCANCEL:
         /* User pressed cancel.  Just take down dialog box. */
         EndDialog (hwnd, 0);
         break;

     /*  User single clicked or doubled clicked in listbox -
      *  Single click means fill edit box with selection.
      *  Double click means go ahead and open the selection.
      */
     case DLGOPEN_FILE_LISTBOX:
     case DLGOPEN_DIR_LISTBOX:

         switch (HIWORD(lParam)) {
       /* Single click case */
       case 1:
           /* Get selection, which may be either a prefix to a
            * new search path or a filename. DlgDirSelect parses
            * selection, and appends a backslash if selection
            * is a prefix
            */
           DlgDirSelect(hwnd,szFileName,wParam);
           w = lstrlen(szFileName)-1;
           c = szFileName[w];
           switch (c) {
         case ':':
             lstrcat (szFileName,".");
             break;
         case '\\':
         case '/':
             szFileName[w] = 0;
             break;
           }
           SetDlgItemText(hwnd, DLGOPEN_EDIT, szFileName);
           break;
       /* Double click case - first click has already been
        * processed as single click
        */
       case 2:
           PostMessage (hwnd,WM_COMMAND,IDOK,0L);
           break;
         }
         break;

     case DLGOPEN_EDIT:
         DlgCheckOkEnable(hwnd, DLGOPEN_EDIT, HIWORD(lParam));
         break;

     case DLGOPEN_FOLDOUT:
         GetWindowRect(hwnd,&rc);
         GetWindowRect(GetDlgItem(hwnd,DLGOPEN_BIG),&rcCtl);

         if ((rcCtl.left <= rc.right) && (rcCtl.top <= rc.bottom))
        GetWindowRect (GetDlgItem (hwnd, DLGOPEN_SMALL), &rcCtl);

         SetWindowPos (hwnd,
           NULL,
           0,
           0,
           rcCtl.left - rc.left,
           rc.bottom - rc.top,
           SWP_NOZORDER | SWP_NOMOVE);
         break;
       }
   default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : static void NEAR DlgCheckOkEnable(hwnd, idEdit, message)   *
  *                      *
  *  PURPOSE    : Enables the <OK> button in a dialog box iff the edit item  *
  *     contains text.               *
  *                      *
  ****************************************************************************
 static void NEAR DlgCheckOkEnable(hwnd, idEdit, message)

 HWND  hwnd;
 int  idEdit;
 unsigned message;
 {
     if (message == EN_CHANGE) {
   EnableWindow ( GetDlgItem (hwnd, IDOK),
            (BOOL)SendMessage (GetDlgItem (hwnd, idEdit),
             WM_GETTEXTLENGTH,
             0, 0L));
     }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : AddExt (pch, ext)              *
  *                      *
  *  PURPOSE    : Add an extension to a filename if none is already specified*
  *                      *
  ****************************************************************************
 static void NEAR AddExt (pch,ext)

 char *pch;    /* File name    */
 char *ext;    /* Extension to add */
 {
     char acExt[20];
     char *pext = acExt;

     while (*ext && *ext != '.')
   ext++;
     while (*ext && *ext != ';')
   *pext++ = *ext++;
     *pext = 0;
     pext = acExt;

     while (*pch == '.') {
   pch++;
   if ((*pch == '.') && pch[1] == '\\')
       pch += 2;          /* ..\ */
   if (*pch == '\\')
       pch++;         /* .\ */
     }
     while (*pch != '\0')
   if (*pch++ == '.')
       return;

     // *pch++ = '.';
     do
   *pch++ = *pext;
     while (*pext++ != '\0');
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : FSearchSpec (sz)              *
  *                      *
  *  PURPOSE    : Checks to see if NULL-terminated strings contains a "*" or *
  *     a "?".                 *
  *                      *
  *  RETURNS    : TRUE  - if the above characters are found in the string    *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 static BOOL NEAR FSearchSpec(sz)
 char  *sz;
 {
     for (; *sz ;sz++) {
   if (*sz == '*' || *sz == '?')
       return TRUE;
     }
     return FALSE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : static char * NEAR FillListBox (hDlg,pFile)        *
  *                      *
  *  PURPOSE    : Fill list box with filenames that match specifications, and*
  *     fills the static field with the path name.        *
  *                      *
  *  RETURNS    : A pointer to the pathname.                    *
  *                      *
  ****************************************************************************
 static char * NEAR FillListBox (hDlg,pFile)

 HWND  hDlg;
 char  *pFile;  /* [path]{list of file wild cards, separated by ';'} */
 {
     char  ach[20];
     char  *pch;
     char  *pDir;   /* Directory name or path */

     pch  = pFile;
     pDir = ach;

     while (*pch && *pch != ';')
   pch++;
     while ((pch > pFile) && (*pch != '/') && (*pch != '\\'))
   pch--;
     if (pch > pFile) {
        *pch = 0;
        lstrcpy (pDir, pFile);
        pFile = pch + 1;
     }
     else {
        lstrcpy (pDir,".");
     }

     DlgDirList (hDlg, pDir, DLGOPEN_DIR_LISTBOX, DLGOPEN_PATH,ATTRDIRLIST);
     SendDlgItemMessage (hDlg, DLGOPEN_FILE_LISTBOX, LB_RESETCONTENT, 0, 0L);
     SendDlgItemMessage (hDlg, DLGOPEN_FILE_LISTBOX, WM_SETREDRAW, FALSE, 0L);
     pDir = pFile;       /* save pFile to return */
     while (*pFile) {
   pch = ach;
   while (*pFile==' ')
       pFile++;
   while (*pFile && *pFile != ';')
       *pch++ = *pFile++;
   *pch = 0;
   if (*pFile)
       pFile++;
   SendDlgItemMessage (hDlg,
           DLGOPEN_FILE_LISTBOX,
           LB_DIR,ATTRFILELIST,
           (LONG)(LPSTR)ach);
     }
     SendDlgItemMessage (hDlg, DLGOPEN_FILE_LISTBOX, WM_SETREDRAW, TRUE, 0L);
     InvalidateRect (GetDlgItem (hDlg, DLGOPEN_FILE_LISTBOX), NULL, TRUE);

     return pDir;
 }


 DRAWDIB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\DRAWDIB.C

 /****************************************************************************
  *                         *
  *  MODULE  : DrawDIB.c                   *
  *                         *
  *  PURPOSE  : Handles most of the SHOWDIB's DIB drawing and clipboard      *
  *      operations.                   *
  *                         *
  *  FUNCTIONS  :                     *
  *      PrintDIB()     -  Sets the current DIB bits to the   *
  *              printer DC.            *
  *                         *
  *      AppPaint()     -  Sets the DIB/bitmap bits on the    *
  *              screen or the given device.        *
  *                         *
  *      DrawSelect()     -  Draws selected clip rectangle on   *
  *              the DC/screen.           *
  *                         *
  *      NormalizeRect()   -  Swaps reversed rectangle coords.   *
  *                         *
  *      TrackMouse()     -  Draws rubberbanding rectangle and  *
  *              displays it's dimensions.          *
  *                         *
  *      BandDIB()     -  Outputs DIB in bands to device.    *
  *                         *
  *      SizeWindow()     -  Sizes app. window based on client  *
  *              dimensions and style.         *
  *                         *
  *      GetRealClientRect()   -  Calculates client rectangle dimen- *
  *              sions if scrollbars are present.   *
  *                         *
  *      SetScrollRanges()   -  Sets global scroll ranges.         *
  *                         *
  *      CopyHandle()     -  Makes a copy of memory block.      *
  *                         *
  *      CopyPalette()    -  Makes a copy of the GDI logical    *
  *              palette.             *
  *                         *
  *      CopyBitmap()     -  Copies given bitmap to another.    *
  *                         *
  *      CropBitmap()     -  Crops a bitmap to the given size.  *
  *                         *
  *      RenderFormat()   -  renders currently displayed DIB    *
  *              in CF_BITMAP or CF_DIB format.     *
  *                         *
  *      RealizeDibFormat()   -  Realizes the DIB in given format.  *
  *                         *
  *      ErrMsg()     -  Pops an error message to user.     *
  *                         *
  *      fDialog()     -  Displays a dialog box.         *
  *                         *
  *      AppAbout()     -  Shows the About.. dialog box.      *
  *                         *
  ****************************************************************************
 #include <windows.h>
 #include <io.h>
 #include <stdio.h>
 #include "showdib.h"

 POINT          ptSize;      /* Stores DIB dimensions           */

 /****************************************************************************
  *                      *
  *  FUNCTION   :  PrintDIB(HWND hWnd, HDC hDC, int x, int y, int dx, int dy)*
  *                      *
  *  PURPOSE    :  Set the DIB bits to the printer DC.          *
  *                      *
  ****************************************************************************
 void PrintDIB (hWnd, hDC, x, y, dx, dy)
 HWND hWnd;
 HDC hDC;
 int x, y;
 int dx, dy;

 {
     BITMAPINFOHEADER bi;
     int dibX,  dibY;
     int dibDX, dibDY;

     if (!bLegitDraw)
         return;

     DibInfo (hbiCurrent, &bi);

     if (IsRectEmpty (&rcClip)){
         dibX  = 0;
         dibY  = 0;
         dibDX = (int)bi.biWidth;
         dibDY = (int)bi.biHeight;
     }
     else{
         dibX  = rcClip.left;
   dibY  = (int)bi.biHeight - 1 - rcClip.bottom;
         dibDX = rcClip.right  - rcClip.left;
         dibDY = rcClip.bottom - rcClip.top;
     }

     if (hdibCurrent){
   /* Stretch the DIB to printer DC */
         StretchDibBlt ( hDC,
       x,
       y,
       dx,
       dy,
       hdibCurrent,
       dibX,
       dibY,
       dibDX,
       dibDY,
       SRCCOPY);
     }
     else if (achFileName[0]) {

   SetMapMode (hDC, MM_ANISOTROPIC);
   SetViewportOrg (hDC, x, y);
   SetViewportExt (hDC, dx, dy);

   BandDIB (hWnd, hDC, 0, 0);
     }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   :  AppPaint(HWND hWnd, HDC hDC, int x, int y)        *
  *                      *
  *  PURPOSE    :  Sets the DIB/bitmap bits on the screen or the given device*
  *                      *
  ****************************************************************************
 void AppPaint (hWnd, hDC, x, y)

 HWND hWnd;
 HDC hDC;
 int x, y;
 {
     HPALETTE hpalT;
     BITMAPINFOHEADER bi;
     LPBITMAPINFOHEADER lpbi;

     SetWindowOrg (hDC, x, y);
     SetBkMode (hDC, wTransparent);

     if (bLegitDraw) {
   hpalT = SelectPalette (hDC, hpalCurrent, FALSE);
   RealizePalette (hDC);

         if (hbmCurrent && !bDIBToDevice) {
       DrawBitmap (hDC, 0, 0, hbmCurrent, SRCCOPY);
         }
         else if (hdibCurrent) {
       DibInfo (hdibCurrent, &bi);
       DibBlt (hDC,
         0,
         0,
         (int)bi.biWidth,
         (int)bi.biHeight,
         hdibCurrent,
         0,
         0,
         SRCCOPY);
         }
         else if (achFileName[0]) {
       BandDIB (hWnd, hDC, 0, 0);
         }

         SelectPalette(hDC,hpalT,FALSE);
     }

     DrawSelect(hDC, TRUE);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   :  DrawSelect(HDC hdc, BOOL fDraw)          *
  *                      *
  *  PURPOSE    :  Draws the selected clip rectangle with its dimensions on  *
  *      the DC/screen               *
  *                      *
  ****************************************************************************
 void DrawSelect( hdc, fDraw)

 HDC hdc;
 BOOL fDraw;
 {
     char  sz[80];
     DWORD dw;
     int   x,y,len,dx,dy;
     HDC   hdcBits;
     HBITMAP hbm;

     if (!IsRectEmpty (&rcClip)) {

   /* If a rectangular clip region has been selected, draw it */
         PatBlt(hdc, rcClip.left,    rcClip.top,        rcClip.right-rcClip.le
         PatBlt(hdc, rcClip.left,    rcClip.bottom, 1, -(rcClip.bottom-rcClip.
         PatBlt(hdc, rcClip.right-1, rcClip.top, 1,   rcClip.bottom-rcClip.top
         PatBlt(hdc, rcClip.right,   rcClip.bottom-1, -(rcClip.right-rcClip.le

   /* Format the dimensions string ...*/
   wsprintf( sz,
       "%dx%d",
       rcClip.right  - rcClip.left,
       rcClip.bottom - rcClip.top );
         len = lstrlen(sz);

   /* ... and center it in the rectangle */
   dw = GetTextExtent (hdc, sz, len);
   dx = LOWORD (dw);
   dy = HIWORD (dw);
   x  =  (rcClip.right  + rcClip.left - dx) / 2;
   y  =  (rcClip.bottom + rcClip.top  - dy) / 2;

   hdcBits = CreateCompatibleDC (hdc);
   SetTextColor (hdcBits, 0xFFFFFFL);
   SetBkColor (hdcBits, 0x000000L);

   /* Output the text to the DC */
   if (hbm = CreateBitmap (dx, dy, 1, 1, NULL)){
       hbm = SelectObject (hdcBits, hbm);
       ExtTextOut (hdcBits, 0, 0, 0, NULL, sz, len, NULL);
       BitBlt (hdc, x, y, dx, dy, hdcBits, 0, 0, SRCINVERT);
       hbm = SelectObject (hdcBits, hbm);
       DeleteObject (hbm);
         }
   DeleteDC (hdcBits);
     }
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : NormalizeRect(RECT *prc)            *
  *                      *
  *  PURPOSE    : If the rectangle coordinates are reversed, swaps them      *
  *                      *
  ****************************************************************************
 void PASCAL NormalizeRect (prc)
 RECT *prc;
 {
     if (prc->right < prc->left)
         SWAP(prc->right,prc->left);
     if (prc->bottom < prc->top)
         SWAP(prc->bottom,prc->top);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : TrackMouse(HWND hwnd, POINT pt)          *
  *                      *
  *  PURPOSE    : Draws a rubberbanding rectangle and displays it's          *
  *     dimensions till the mouse button is released        *
  *                      *
  ****************************************************************************
 void TrackMouse (hwnd, pt)
 HWND hwnd;
 POINT pt;
 {
     POINT ptBase;
     HDC   hdc;
     MSG   msg;
     POINT ptOrigin;
     RECT  rcClient;

     hdc = GetDC(hwnd);
     SetCapture(hwnd);

     GetClientRect(hwnd,&rcClient);

     /* Get mouse coordinates relative to origin of DIB */
     ptOrigin.x = GetScrollPos(hwnd,SB_HORZ);
     ptOrigin.y = GetScrollPos(hwnd,SB_VERT);

     pt.x += ptOrigin.x;
     pt.y += ptOrigin.y;

     /* Display the coordinates */
     SetWindowOrg(hdc,ptOrigin.x,ptOrigin.y);
     DrawSelect(hdc,FALSE);

     /* Initialize clip rectangle to the point */
     rcClip.left   = pt.x;
     rcClip.top    = pt.y;
     rcClip.right  = pt.x;
     rcClip.bottom = pt.y;

     /* Eat mouse messages until a WM_LBUTTONUP is encountered. Meanwhile
      * continue to draw a rubberbanding rectangle and display it's dimensions
      */
     for (;;){
   WaitMessage();
   if (PeekMessage(&msg,NULL,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE)){
             DrawSelect(hdc,FALSE);

             rcClip.left   = pt.x;
             rcClip.top    = pt.y;
             rcClip.right  = LOWORD(msg.lParam) + ptOrigin.x;
             rcClip.bottom = HIWORD(msg.lParam) + ptOrigin.y;

             NormalizeRect(&rcClip);
             DrawSelect(hdc,TRUE);

             if (msg.message == WM_LBUTTONUP)
     break;
         }
   else
       continue;
     }

     ReleaseCapture();
     ReleaseDC(hwnd,hdc);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : BandDIB(HWND hWnd, HDC hDC, int x, int y)        *
  *                      *
  *  PURPOSE    : Outputs the DIB in bands to a device or the screen, using  *
  *     the maximum possible band size.          *
  *                      *
  ****************************************************************************
 void BandDIB (hWnd, hDC, x, y)
 HWND hWnd;
 HDC hDC;
 int x, y;
 {
     HBITMAP         hBitmap, hOld ;
     HDC          hMemDC ;
     LPSTR         pBuf;
     LPBITMAPINFOHEADER lpbi;
     WORD         wRead, wActualPosition, wScansLeft  ;
     DWORD         dwMapSize;
     DWORD         dwScans;
     WORD         wBitmapHeight;
     RECT         Rect;
     HANDLE         hBuf;
     BOOL         bSuccess = FALSE;
     int          nBandSize;
     HPALETTE         hOldMemPal;
     HPALETTE         hOldPal;
     int          fh;
     OFSTRUCT         of;

     /* Open the map file and get the information out */
     fh = OpenFile (achFileName, (LPOFSTRUCT)&of, OF_READ);

     if (fh == -1)
   return;
     lpbi = (VOID FAR *)GlobalLock(hbiCurrent);
     if (!lpbi){
   _lclose (fh);
   return;
     }

     /* Compute scan size in bytes */
     dwScans = WIDTHBYTES((DWORD)lpbi->biWidth * lpbi->biBitCount);

     wBitmapHeight = (WORD)lpbi->biHeight ;
     wScansLeft    = (WORD)lpbi->biHeight ;

     hMemDC = NULL;
     for ( nBandSize = wScansLeft;
     nBandSize >= MINBAND || nBandSize == wScansLeft;
     nBandSize -= BANDINCREMENT) {

   /* Attempt to maximize band size by trying to allocate a buffer
    * for the given band size. If allocation fails, try again with the
    * smaller band size.
    */
   hBuf = GlobalAlloc (GMEM_FIXED | GMEM_ZEROINIT, dwScans * nBandSize) ;
   if (!hBuf)
       continue;

   /* Show success and exit loop if we're going to set bits to device. */
   if (bDIBToDevice) {
       hMemDC = 1;
       break;
   }
   else {
       /* Create a device-dependent bitmap to hold the bits */
       hBitmap = CreateCompatibleBitmap (hDC,
                 (WORD)lpbi->biWidth,
                 nBandSize);
       if (!hBitmap) {
     /* Try again for the next smaller band size */
     GlobalFree (hBuf);
     continue;
       }

       /* Create a memory context for the bitmap */
       if (!(hMemDC = CreateCompatibleDC (hDC))) {
     GlobalFree (hBuf);
     DeleteObject (hBitmap);
     continue;
       } else
     /* Success in creating a DC */
     break;
   }
     }
     if (!hMemDC) {

   /* We failed allocation , so give error message and quit */
   if (GetFocus () == hWnd) {
       ErrMsg ("No memory available!");
       ValidateRect (hWnd, (LPRECT) (NULL));
   } else
       MessageBeep(0);

   GlobalUnlock(hbiCurrent);
   _lclose (fh);
   return;
     }
     pBuf = GlobalLock (hBuf);

     /* Calculate number of bytes to be transferred */
     dwMapSize = dwScans * nBandSize ;

     /* Manipulate palette appropriately */
     if (!bDIBToDevice)
   hOldMemPal = SelectPalette (hMemDC, hpalCurrent, 0) ;

     /* Now get to the start of the map in the file */
     _llseek(fh, dwOffset, SEEK_SET);

     /* we are now all set to start off */
     wActualPosition = wScansLeft ;

     Rect.left  = 0;
     Rect.right = (WORD)lpbi->biWidth;

     hOldPal = SelectPalette(hDC, hpalCurrent, 0);
     RealizePalette(hDC);

     do {
   /* Read in nBandSize scans or whatever is left */
   if (wScansLeft > nBandSize)
       wRead = nBandSize ;
   else
       wRead = wScansLeft ;

   Rect.bottom = wActualPosition;
   wActualPosition -= wRead ;
   Rect.top = wActualPosition;

   dwMapSize = ((DWORD) wRead) * dwScans ;

   /* Now read in the map to the global buffer */
   if (RectVisible (hDC, &Rect)) {
       lread(fh, (LPSTR)pBuf, dwMapSize);

       if (bDIBToDevice) {
     if (wRead != SetDIBitsToDevice (hDC, x, y,
             (WORD)lpbi->biWidth,
             wBitmapHeight,
             0,
             0,
             wBitmapHeight - wScansLeft,
             wRead,
             pBuf,
             (LPBITMAPINFO)lpbi,
             fPalColors ?
             DIB_PAL_COLORS :
             DIB_RGB_COLORS)){
         ErrMsg ("Could not draw DIB scans to device!");
         GlobalUnlock (hBuf);
         GlobalFree (hBuf);
         GlobalUnlock(hbiCurrent);
         _lclose (fh);
         return;
     }
       } else {
     lpbi->biHeight = wRead ;

     /* Set the DIB bits to a device-dependent format */
     if ((WORD)lpbi->biHeight != SetDIBits (hMemDC,
                    hBitmap,
                    0,
                    (WORD)lpbi->biHeight,
                    pBuf,
                    (LPBITMAPINFO)lpbi,
                    fPalColors ?
                    DIB_PAL_COLORS :
                    DIB_RGB_COLORS)){
         ErrMsg ("Could not draw DIB scans!");
         GlobalUnlock (hBuf);
         GlobalFree (hBuf);
         GlobalUnlock(hbiCurrent);
         _lclose (fh);
         return;
     }

     /* Blt own map onto the screen, remembering the point to start */
     hOld = SelectObject (hMemDC, hBitmap) ;
     if (!BitBlt (hDC, 0, wActualPosition,
            (WORD)lpbi->biWidth,
            (WORD)lpbi->biHeight,
            hMemDC, 0, 0, SRCCOPY)){
         ErrMsg ("Could not draw map to screen!");
         GlobalUnlock (hBuf);
         GlobalFree (hBuf);
         GlobalUnlock(hbiCurrent);
         _lclose (fh);
         return;
     }
     SelectObject (hMemDC, hOld) ;

     /* Restore the value of bitmap height */
     lpbi->biHeight = wBitmapHeight ;
       }
   }
   else {
       /* This chunk is not visible, seek over the data in the file */
       _llseek(fh, dwMapSize, SEEK_CUR);
   }
   wScansLeft -= wRead ;
     } while (wScansLeft > 0 ) ;

     /* Delete the objects just created above */
     GlobalUnlock (hBuf);
     GlobalFree (hBuf);
     SelectPalette (hDC, hOldPal, 0);

     /* Set success flag */
     bSuccess = TRUE;

     if (!bDIBToDevice) {
   SelectPalette (hMemDC, hOldMemPal, 0);
   DeleteDC (hMemDC) ;
   DeleteObject (hBitmap) ;
     }
     GlobalUnlock(hbiCurrent);

     /* Close the file */
     _lclose (fh);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SizeWindow(HWND hWnd)              *
  *                      *
  *  PURPOSE    : Sizes the app. window based on client dimensions (DIB      *
  *     dimensions) and style. Sets the caption text.        *
  *                      *
  ****************************************************************************
 void SizeWindow (hWnd)
 HWND hWnd;
 {
     char  *pstr;
     char  Name[60];
     RECT  Rectangle;
     int   dx,dy;
     POINT pt;
     BITMAPINFOHEADER bi;

     /* Get information about current DIB */
     DibInfo(hbiCurrent,&bi);

     /* Extract the filename from the full pathname */
     pstr = achFileName + lstrlen(achFileName) - 1;
     while ((*pstr != '\\') && (*pstr != ':') && (pstr >= achFileName))
       pstr--;
     pstr++;

     /* Format filename along with the DIB attributes */
     wsprintf (Name,
         "%ls (%ls %dx%dx%d%ls)",
         (LPSTR)szAppName,
         (LPSTR)pstr,
         (WORD)bi.biWidth,
         (WORD)bi.biHeight,
         (WORD)bi.biBitCount,
         bi.biCompression == BI_RGB  ? (LPSTR)" RGB" :
         bi.biCompression == BI_RLE8 ? (LPSTR)" RLE8" : (LPSTR)" RLE4" );

     /* Show formatted text in the caption bar */
     SetWindowText (hWnd, Name);

     /* Store the size in ptSize, so the scroll bars will work. */
     ptSize.x = (WORD)bi.biWidth;
     ptSize.y = (WORD)bi.biHeight;

     if (IsZoomed (hWnd))
   SetScrollRanges (hWnd);
     else {
   Rectangle.left   = 0;
   Rectangle.top   = 0;
   Rectangle.right  = (WORD)bi.biWidth;
   Rectangle.bottom = (WORD)bi.biHeight;

   /* Compute the size of the window rectangle based on the given
    * client rectangle size and the window style, then size the
    * window.
    */
   AdjustWindowRect (&Rectangle, dwStyle, TRUE);
   SetWindowPos (hWnd, (HWND)NULL, 0, 0,
           Rectangle.right  - Rectangle.left + 1,
           Rectangle.bottom - Rectangle.top + 1,
           SWP_NOMOVE | SWP_NOZORDER);
     }

     InvalidateRect(hWnd,NULL,TRUE);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : GetRealClientRect(HWND hwnd, LPRECT lprc)        *
  *                      *
  *  PURPOSE    : Calculates the client rectangle taking scrollbars into     *
  *     consideration.               *
  *                      *
  ****************************************************************************
 void GetRealClientRect (hwnd, lprc)
 HWND hwnd;
 PRECT lprc;
 {
     DWORD dwStyle;

     dwStyle = GetWindowLong (hwnd, GWL_STYLE);
     GetClientRect (hwnd,lprc);

     if (dwStyle & WS_HSCROLL)
   lprc->bottom += GetSystemMetrics (SM_CYHSCROLL);

     if (dwStyle & WS_VSCROLL)
   lprc->right  += GetSystemMetrics (SM_CXVSCROLL);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SetScrollRanges(hwnd)              *
  *                      *
  *  PURPOSE    :                  *
  *                      *
  ****************************************************************************
 void SetScrollRanges(hwnd)

 HWND hwnd;
 {
     RECT       rc;
     int        iRangeH, iRangeV, i;
     static int iSem = 0;

     if (!iSem){
         iSem++;
   GetRealClientRect (hwnd, &rc);

   for (i = 0; i < 2; i++){
             iRangeV = ptSize.y - rc.bottom;
             iRangeH = ptSize.x - rc.right;

             if (iRangeH < 0) iRangeH = 0;
             if (iRangeV < 0) iRangeV = 0;

       if (GetScrollPos ( hwnd,
              SB_VERT) > iRangeV ||
              GetScrollPos (hwnd, SB_HORZ) > iRangeH)
     InvalidateRect (hwnd, NULL, TRUE);

       SetScrollRange (hwnd, SB_VERT, 0, iRangeV, TRUE);
       SetScrollRange (hwnd, SB_HORZ, 0, iRangeH, TRUE);

       GetClientRect (hwnd, &rc);
         }
         iSem--;
     }
 }

 /*********** THE FOLLOWING FUNCTIONS ARE FOR CLIPBOARD SUPPORT **************
 /****************************************************************************
  *                      *
  *  FUNCTION   : CopyHandle (HANDLE h)              *
  *                      *
  *  PURPOSE    : Makes a copy of the given global memory block.       *
  *                      *
  *  RETURNS    : A handle to the new block.            *
  *                      *
  ****************************************************************************
 HANDLE CopyHandle (h)
 HANDLE h;
 {
     BYTE huge *lpCopy;
     BYTE huge *lp;
     HANDLE hCopy;
     DWORD  dwLen;

     dwLen = GlobalSize (h);
     if (hCopy = GlobalAlloc (GHND, dwLen)) {

   lpCopy = (BYTE huge *)GlobalLock (hCopy);
   lp     = (BYTE huge *)GlobalLock (h);
   while (dwLen--) *lpCopy++ = *lp++;
   GlobalUnlock (hCopy);
   GlobalUnlock (h);
     }
     return hCopy;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : CopyPalette(HPALETTE hpal)            *
  *                      *
  *  PURPOSE    : Makes a copy of a GDI logical palette          *
  *                      *
  *  RETURNS    : A handle to the new palette.            *
  *                      *
  ****************************************************************************
 HPALETTE CopyPalette (hpal)
 HPALETTE hpal;
 {
     PLOGPALETTE ppal;
     int         nNumEntries;

     if (!hpal)
   return NULL;

     GetObject(hpal,sizeof(int),(LPSTR)&nNumEntries);

     if (nNumEntries == 0)
         return NULL;

     ppal = (PLOGPALETTE)LocalAlloc(LPTR,sizeof(LOGPALETTE) +
                 nNumEntries * sizeof(PALETTEENTRY));

     if (!ppal)
         return NULL;

     ppal->palVersion    = PALVERSION;
     ppal->palNumEntries = nNumEntries;

     GetPaletteEntries(hpal,0,nNumEntries,ppal->palPalEntry);

     hpal = CreatePalette(ppal);

     LocalFree((HANDLE)ppal);
     return hpal;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : CopyBitmap (HBITMAP hbm)            *
  *                      *
  *  PURPOSE    : Copies the given bitmap to another.          *
  *                      *
  *  RETURNS    : A handle to the new bitmap.            *
  *                      *
  ****************************************************************************
 HBITMAP CopyBitmap (hbm)
 HBITMAP hbm;
 {
     BITMAP  bm;
     RECT    rc;

     if (!hbm)
          return NULL;

     GetObject (hbm, sizeof(BITMAP), (LPSTR)&bm);
     rc.left   = 0;
     rc.top    = 0;
     rc.right  = bm.bmWidth;
     rc.bottom = bm.bmHeight;

     return CropBitmap (hbm, &rc);
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   :  CropBitmap (hbm,lprect)            *
  *                      *
  *  PURPOSE    :  Crops a bitmap to a new size specified by the lprect      *
  *      parameter.                *
  *                      *
  *  RETURNS    :  A handle to the new bitmap.            *
  *                      *
  ****************************************************************************
 HBITMAP CropBitmap (hbm, prc)
 HBITMAP hbm;
 PRECT prc;
 {
     HDC     hMemDCsrc;
     HDC     hMemDCdst;
     HDC     hdc;
     HBITMAP hNewBm;
     BITMAP  bm;
     int     dx,dy;

     if (!hbm)
          return NULL;

     hdc = GetDC (NULL);
     hMemDCsrc = CreateCompatibleDC (hdc);
     hMemDCdst = CreateCompatibleDC (hdc);

     GetObject (hbm, sizeof(BITMAP), (LPSTR)&bm);
     dx = prc->right  - prc->left;
     dy = prc->bottom - prc->top;

     hNewBm = CreateBitmap (dx, dy, bm.bmPlanes, bm.bmBitsPixel, NULL);
     if (hNewBm){
   SelectObject (hMemDCsrc, hbm);
   SelectObject (hMemDCdst, hNewBm);

   BitBlt (hMemDCdst,
     0,
     0,
     dx,
     dy,
     hMemDCsrc,
     prc->left,
     prc->top,
     SRCCOPY);
     }

     ReleaseDC (NULL,hdc);
     DeleteDC (hMemDCsrc);
     DeleteDC (hMemDCdst);
     return hNewBm;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : RenderFormat(int cf)              *
  *                      *
  *  PURPOSE    : Renders the currently displayed DIB in CF_DIB or      *
  *     CF_BITMAP format.The bitmap is clipped to the current      *
  *     rcClip.                *
  *                      *
  *  RETURNS    : A handle to the DIB              *
  *                      *
  ****************************************************************************
 HANDLE RenderFormat (cf)
 int cf;
 {
     HANDLE  h = NULL;
     HBITMAP hbm;

     if (!bLegitDraw)
         return NULL;

     switch (cf){
         case CF_BITMAP:
       if (hbmCurrent && !IsRectEmpty (&rcClip))
     h = CropBitmap (hbmCurrent, &rcClip);
       else{
                 if (hbmCurrent)
         h = CopyBitmap (hbmCurrent);
                 else if (hdibCurrent)
         h = BitmapFromDib (hdibCurrent, hpalCurrent);
     else if (achFileName[0] && (hdibCurrent = OpenDIB (achFileName)))
         h = BitmapFromDib (hdibCurrent, hpalCurrent);
                 else
                     h = NULL;

     if (h && !IsRectEmpty (&rcClip)){
         hbm = CropBitmap (h,&rcClip);
         DeleteObject (h);
                     h = hbm;
                 }
             }
             break;

         case CF_DIB:
       if (!IsRectEmpty (&rcClip)){
     if (hbm = RenderFormat (CF_BITMAP)){
         h = DibFromBitmap (hbm, BI_RGB, 0, hpalCurrent);
         DeleteObject (hbm);
                 }
             }
       else{
                 if (!hdibCurrent && hbmCurrent)
         h = DibFromBitmap (hbmCurrent, BI_RGB, 0, hpalCurrent);
                 else if (hdibCurrent)
         h = CopyHandle (hdibCurrent);
                 else if (achFileName[0])
         h = OpenDIB (achFileName);
                 else
                     h = NULL;
             }
             break;

         case CF_PALETTE:
             if (hpalCurrent)
     h = CopyPalette (hpalCurrent);
             break;
     }
     return h;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   :  RealizeDibFormat(DWORD biStyle, WORD biBits)        *
  *                      *
  *  PURPOSE    :  Realize the current DIB in the specifed format      *
  *      This function is used to get a specific format of CF_DIB  *
  *                      *
  *          biStyle    DIB format    RGB or RLE        *
  *          biBits    Bits per pixel  1,4,8,24        *
  *                      *
  *  RETURNS    :  A handle to the created DIB.            *
  *                      *
  ****************************************************************************
 HANDLE RealizeDibFormat (biStyle, biBits)
 DWORD biStyle;
 WORD biBits;
 {
     BITMAPINFOHEADER bi;

     if (!bLegitDraw)
         return NULL;

     DibInfo (hbiCurrent, &bi);

     /*  Do we have the requested format already? */
     if (bi.biCompression == biStyle && bi.biBitCount == biBits){
         if (!hdibCurrent)
       hdibCurrent = RenderFormat (CF_DIB);
     }
     else{
         if (!hbmCurrent)
       hbmCurrent = RenderFormat (CF_BITMAP);

   if (hbmCurrent){
             if (hdibCurrent)
     GlobalFree (hdibCurrent);

       hdibCurrent = DibFromBitmap (hbmCurrent, biStyle, biBits, hpalCurrent);
         }
     }

     return hdibCurrent;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : ErrMsg (PSTR sz,...)              *
  *                      *
  *  PURPOSE    : Opens a Message box with a error message in it.The user can*
  *     select the OK button to continue          *
  *                      *
  *  RETURNS    : FALSE to indicate an error has occured.        *
  *                      *
  ****************************************************************************
 int ErrMsg (PSTR sz,...)
 {
     char ach[128];

     wvsprintf (ach, sz, (LPSTR)(&sz+1));   /* Format the string */
     MessageBox (NULL, ach, NULL, MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
     return FALSE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : fDialog(int id,HWND hwnd,FARPROC fpfn)         *
  *                      *
  *  PURPOSE    : This function displays a dialog box          *
  *                      *
  *  RETURNS    : The exit code.               *
  *                      *
  ****************************************************************************
 BOOL fDialog (id, hwnd, fpfn)
 int id;
 HWND hwnd;
 FARPROC fpfn;
 {
     BOOL  f;
     HANDLE  hInst;

     hInst = GetWindowWord (hwnd, GWW_HINSTANCE);
     fpfn  = MakeProcInstance (fpfn, hInst);
     f = DialogBox (hInst, MAKEINTRESOURCE(id), hwnd, fpfn);
     FreeProcInstance (fpfn);
     return f;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : AppAbout( hDlg, uiMessage, wParam, lParam )        *
  *                      *
  *  PURPOSE    : Dialog function for the About... dialog box        *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL AppAbout( hDlg, uiMessage, wParam, lParam )

 HWND   hDlg;
 unsigned uiMessage;
 WORD   wParam;
 long   lParam;
 {
     switch (uiMessage) {
         case WM_COMMAND:
             if (wParam == IDOK)
     EndDialog (hDlg, TRUE);
       break;

   case WM_INITDIALOG:
       return TRUE;
     }
     return FALSE;
 }


 EDITCNTL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\EDITCNTL\EDITCNTL.C

 /****************************************************************************

     PROGRAM: EditCntl.c

     PURPOSE: Creates an edit window

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

     COMMENTS:

   After setting up the application's window, the size of the client
   area is determined and a child window is created to use for editing.

 ****************************************************************************/

 #include "windows.h"
 #include "editcntl.h"

 HANDLE hInst;

 HANDLE hAccTable;                                /* handle to accelerator tab
 HWND hEditWnd;              /* handle to edit window */
 HWND hwnd;                    /* handle to main windows  */

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "EditCntlMenu";
     wc.lpszClassName = "EditCntlWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     RECT            Rect;

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "EditCntlAcc");

     hwnd = CreateWindow(
         "EditCntlWClass",
         "EditCntl Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     GetClientRect(hwnd, (LPRECT) &Rect);

     /* Create a child window */

     hEditWnd = CreateWindow("Edit",
   NULL,
   WS_CHILD | WS_VISIBLE |
   ES_MULTILINE |
   WS_VSCROLL | WS_HSCROLL |
   ES_AUTOHSCROLL | ES_AUTOVSCROLL,
   0,
   0,
   (Rect.right-Rect.left),
   (Rect.bottom-Rect.top),
   hwnd,
   IDC_EDIT,                          /* Child control i.d. */
   hInst,
   NULL);

     if (!hEditWnd) {
   DestroyWindow(hwnd);
   return (NULL);
     }

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_DESTROY    - destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     switch (message) {
   case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 /* file menu commands */

                 case IDM_NEW:
                 case IDM_OPEN:
                 case IDM_SAVE:
                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditCntl Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:
                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditCntl Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "EditCntl Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SETFOCUS:
             SetFocus (hEditWnd);
             break;

         case WM_SIZE:
             MoveWindow(hEditWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
             break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 EDITFILE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\EDITFILE\EDITFILE.C

 /****************************************************************************

     PROGRAM: EditFile.c

     PURPOSE: Loads, saves, and edits text files

     FUNCTIONS:

         WinMain() - calls initialization function, processes message loop
         InitApplication() - initializes window data and registers window
         InitInstance() - saves instance handle and creates main window
         MainWndProc() - processes messages
         About() - processes messages for "About" dialog box
         SaveAsDlg() - save file under different name
         OpenDlg() - let user select a file, and open it.
         UpdateListBox() - Update the list box of OpenDlg
         ChangeDefExt() - Change the default extension
         SeparateFile() - Separate filename and pathname
         AddExt() - Add default extension
         CheckFileName() - Check for wildcards, add extension if needed
         SaveFile() - Save current file
         QuerySaveFile() - Called when some action might lose current contents
         SetNewBuffer() - Set new buffer for edit window

 ****************************************************************************/

 #include "windows.h"
 #include "editfile.h"

 HANDLE hInst;

 HANDLE hAccTable;                                /* handle to accelerator tab
 HWND hEditWnd;                                      /* handle to edit window
 /* Additional includes needed for the fstat() function */

 #include <sys\types.h>
 #include <sys\stat.h>

 char FileName[128];
 char PathName[128];
 char OpenName[128];
 char DefPath[128];
 char DefSpec[13] = "*.*";
 char DefExt[] = ".txt";
 char str[255];

 HANDLE hEditBuffer;                       /* handle to editing buffer      */
 HANDLE hOldBuffer;                        /* old buffer handle        */
 HANDLE hHourGlass;                        /* handle to hourglass cursor
 HANDLE hSaveCursor;                       /* current cursor handle      */
 int hFile;                                /* file handle              */
 int count;                                /* number of chars read or written
 PSTR pBuffer;                             /* address of read/write buffer
 OFSTRUCT OfStruct;                        /* information from OpenFile()
 struct stat FileStatus;                   /* information from fstat()      */
 BOOL bChanges = FALSE;                    /* TRUE if the file is changed
 BOOL bSaveEnabled = FALSE;                /* TRUE if text in the edit buffer
 PSTR pEditBuffer;                         /* address of the edit buffer
 RECT Rect;                                /* dimension of the client window
 HWND hwnd;                                /* handle to main window


 char Untitled[] =                         /* default window title      */
      "Edit File - (untitled)";

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "EditFileMenu";
     wc.lpszClassName = "EditFileWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     RECT            Rect;

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "EditFileAcc");

     hwnd = CreateWindow(
         "EditFileWClass",
         "EditFile Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     GetClientRect(hwnd, (LPRECT) &Rect);

     /* Create a child window */

     hEditWnd = CreateWindow("Edit",
         NULL,
         WS_CHILD | WS_VISIBLE |
         ES_MULTILINE |
         WS_VSCROLL | WS_HSCROLL |
         ES_AUTOHSCROLL | ES_AUTOVSCROLL,
         0,
         0,
         (Rect.right-Rect.left),
         (Rect.bottom-Rect.top),
         hwnd,
         IDC_EDIT,                          /* Child control i.d. */
         hInst,
         NULL);

     if (!hEditWnd) {
         DestroyWindow(hwnd);
         return (NULL);
     }

     /* Get an hourglass cursor to use during file transfers */

     hHourGlass = LoadCursor(NULL, IDC_WAIT);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

         WM_COMMAND    - application menu (About dialog box)
         WM_DESTROY    - destroy window
         WM_SIZE       - window size has changed
         WM_QUERYENDSESSION - willing to end session?
         WM_ENDSESSION - end Windows session
         WM_CLOSE      - close the window
         WM_SIZE       - window resized

     COMMENTS:

         WM_COMMAND processing:

             IDM_NEW - query to save current file if there is one and it has
                       been changed, clear buffer and start new file.

             IDM_OPEN - query to save current file if there is one and it
                        has been changed, open a new file.

             IDM_SAVE - save current file, prompt for name if none exists.

             IDM_SAVEAS - prompt for new filename to save to, save file.

             IDC_EDIT - change "bChanges" flag to indicate if edit buffer has
                       been modified.  Affects actions of IDM_NEW and
                       IDM_OPEN.  Reset when file is saved.

             IDM_EXIT - query to save current file if there is one and it
                        has been changed, then exit.

             IDM_ABOUT - display "About" box.

         When more then one string needs to be sent to a message box,
         sprintf() is used to combine the strings into str[], and then str[]
         is passed to the MessageBox() function.  A message box string cannot
         exceed 255 characters, but may contain \n to generate separate
         lines.

         After the size of the file is determined, only enough memory to store
         the file is allocated for the Edit buffer.  The edit control will
         automatically expand this memory as needed.  Once the file has been
         read into the edit buffer, unlock the memory.  Use whatever was
         obtained from the read() function, even if an error occured.  This
         allows partial salvage of a file with a bad sector.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpOpenDlg, lpSaveAsDlg;

     int Success;                            /* return value from SaveAsDlg()
     int IOStatus;                           /* result of file i/o      */


     switch (message) {
         case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 case IDM_NEW:

                     /* If current file has been modified, query user about
                      * saving it.
                      */

                     if (!QuerySaveFile(hWnd))
                         return (NULL);

                     /* bChanges is set to FALSE to indicate there have been
                      * no changes since the last file save.
                      */

                     bChanges = FALSE;
                     FileName[0] = 0;

                     /* Update the edit buffer */

                     SetNewBuffer(hWnd, NULL, Untitled);
                     break;

                 case IDM_OPEN:
                     if (!QuerySaveFile(hWnd))
                         return (NULL);

                     lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);

                     /* Open the file and get its handle */

                     hFile = DialogBox(hInst, "Open", hWnd, lpOpenDlg);
                     FreeProcInstance(lpOpenDlg);
                     if (!hFile)
                         return (NULL);

                     /* Allocate edit buffer to the size of the file + 1 */

                     hEditBuffer =
                         LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,
           (WORD)(FileStatus.st_size+1));

                     if (!hEditBuffer) {
                         MessageBox(hWnd, "Not enough memory.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (NULL);
                     }
                     hSaveCursor = SetCursor(hHourGlass);
                     pEditBuffer = LocalLock(hEditBuffer);

                     IOStatus = read(hFile, pEditBuffer, FileStatus.st_size);
                     close(hFile);

                     /* # bytes read must equal file size */

                     if (IOStatus != FileStatus.st_size) {

                         sprintf(str, "Error reading %s.", FileName);
                         SetCursor(hSaveCursor);      /* Remove the hourglass
                         MessageBox(hWnd, str, NULL, MB_OK | MB_ICONEXCLAMATIO
                     }

                     LocalUnlock(hEditBuffer);

                     /* Set up a new buffer and window title */

                     sprintf(str, "EditFile - %s", FileName);
                     SetNewBuffer(hWnd, hEditBuffer, str);
                     SetCursor(hSaveCursor);            /* restore the cursor
                     break;

                 case IDM_SAVE:

                     /* If there is no filename, use the saveas command to get
                      * one.  Otherwise, save the file using the current
                      * filename.
                      */

                     if (!FileName[0])
                         goto saveas;
                     if (bChanges)
                         SaveFile(hWnd);
                     break;

                 case IDM_SAVEAS:
 saveas:
                     lpSaveAsDlg = MakeProcInstance(SaveAsDlg, hInst);

                     /* Call the SaveAsDlg() function to get the new filename

                     Success = DialogBox(hInst, "SaveAs", hWnd, lpSaveAsDlg);
                     FreeProcInstance(lpSaveAsDlg);

                     /* If successful, update the window title, save the file

                     if (Success == IDOK) {
                         sprintf(str, "EditFile - %s", FileName);
                         SetWindowText(hWnd, str);
                         SaveFile(hWnd);
                     }
                     break;                                  /* User canceled
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditFile Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:
                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditFile Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_EXIT:
                     QuerySaveFile(hWnd);
                     DestroyWindow(hWnd);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "EditFile Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SETFOCUS:
             SetFocus (hEditWnd);
             break;

         case WM_SIZE:
             MoveWindow(hEditWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
             break;

         case WM_QUERYENDSESSION:             /* message: to end the session?
             return (QuerySaveFile(hWnd));

         case WM_CLOSE:                       /* message: close the window
             if (QuerySaveFile(hWnd))
                 DestroyWindow(hWnd);
             break;

         case WM_DESTROY:
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 /****************************************************************************

     FUNCTION: SaveAsDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Allows user to change name to save file to

     COMMENTS:

         This will initialize the window class if it is the first time this
         application is run.  It then creates the window, and processes the
         message loop until a PostQuitMessage is received.  It exits the
         application by returning the value passed by the PostQuitMessage.

 ****************************************************************************/

 int FAR PASCAL SaveAsDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     char TempName[128];

     switch (message) {
         case WM_INITDIALOG:

             /* If no filename is entered, don't allow the user to save to it

             if (!FileName[0])
                 bSaveEnabled = FALSE;
             else {
                 bSaveEnabled = TRUE;

                 /* Process the path to fit within the IDC_PATH field */

                 DlgDirList(hDlg, DefPath, NULL, IDC_PATH, 0x4010);

                 /* Send the current filename to the edit control */

                 SetDlgItemText(hDlg, IDC_EDIT, FileName);

                 /* Accept all characters in the edit control */

                 SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, 0,
                     MAKELONG(0, 0x7fff));
             }

             /* Enable or disable the save control depending on whether the
              * filename exists.
              */

             EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled);

             /* Set the focus to the edit control within the dialog box */

             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE);                 /* FALSE since Focus was changed

         case WM_COMMAND:
             switch (wParam) {
                 case IDC_EDIT:

                     /* If there was previously no filename in the edit
                      * control, then the save control must be enabled as soon
                      * a character is entered.
                      */

                     if (HIWORD(lParam) == EN_CHANGE && !bSaveEnabled)
                     EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled = TRUE)
                     return (TRUE);

                 case IDOK:

                    /* Get the filename from the edit control */

                     GetDlgItemText(hDlg, IDC_EDIT, TempName, 128);

                     /* If there are no wildcards, then separate the name into
                      * path and name.  If a path was specified, replace the
                      * default path with the new path.
                      */

                     if (CheckFileName(hDlg, FileName, TempName)) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) FileName);
                         if (str[0])
                             strcpy(DefPath, str);

                         /* Tell the caller a filename was selected */

                         EndDialog(hDlg, IDOK);
                     }
                     return (TRUE);

                 case IDCANCEL:

                     /* Tell the caller the user canceled the SaveAs function

                     EndDialog(hDlg, IDCANCEL);
                     return (TRUE);
             }
             break;

     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: OpenDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Let user select a file, and open it.

 ****************************************************************************/

 HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     WORD index;
     PSTR pTptr;
     HANDLE hFile;

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDC_LISTBOX:
                     switch (HIWORD(lParam)) {

                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
                             if (DlgDirSelect(hDlg, str, IDC_LISTBOX))
                                 strcat(str, DefSpec);

                             SetDlgItemText(hDlg, IDC_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 IDC_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));
                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                     }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
                     if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) OpenName);
                         if (str[0])
                             strcpy(DefPath, str);
                         ChangeDefExt(DefExt, DefSpec);
                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     if (!OpenName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                     }

                     AddExt(OpenName, DefExt);

                     /* Open the file */

                     if ((hFile = OpenFile(OpenName, (LPOFSTRUCT) &OfStruct,
                             OF_READ)) == -1) {
                         sprintf(str, "Error %d opening %s.",
                             OfStruct.nErrCode, OpenName);
                         MessageBox(hDlg, str, NULL,
                             MB_OK | MB_ICONHAND);
                     }
                     else {

                         /* Make sure there's enough room for the file */

                         fstat(hFile, &FileStatus);
                         if (FileStatus.st_size > MAXFILESIZE) {
                             sprintf(str,
                     "Not enough memory to load %s.\n%s exceeds %ld bytes.",
                                 OpenName, OpenName, MAXFILESIZE);
                             MessageBox(hDlg, str, NULL,
                                 MB_OK | MB_ICONHAND);
                             return (TRUE);
                         }

                         /* File is opened and there is enough room so return
                          * the handle to the caller.
                          */

                         strcpy(FileName, OpenName);
                         EndDialog(hDlg, hFile);
                         return (TRUE);
                     }
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (TRUE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }

 /****************************************************************************

     FUNCTION: UpdateListBox(HWND);

     PURPOSE: Update the list box of OpenDlg

 ****************************************************************************/

 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* To ensure that the listing is made for a subdir. of
      * current drive dir...
      */
     if (!strchr (DefPath, ':'))
   DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* Remove the '..' character from path if it exists, since this
      * will make DlgDirList move us up an additional level in the tree
      * when UpdateListBox() is called again.
      */
     if (strstr (DefPath, ".."))
   DefPath[0] = '\0';

     SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
 }

 /****************************************************************************

     FUNCTION: ChangeDefExt(PSTR, PSTR);

     PURPOSE: Change the default extension

 ****************************************************************************/

 void ChangeDefExt(Ext, Name)
 PSTR Ext, Name;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr)
         if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
             strcpy(Ext, pTptr);
 }

 /****************************************************************************

     FUNCTION: SeparateFile(HWND, LPSTR, LPSTR, LPSTR)

     PURPOSE: Separate filename and pathname

 ****************************************************************************/

 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;
     char  cTmp;

     lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {
         lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     lstrcpy(lpDestFileName, lpTmp + 1);
     cTmp = *(lpTmp + 1);
     lstrcpy(lpDestPath, lpSrcFileName);
      *(lpTmp + 1) = cTmp;
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }

 /****************************************************************************

     FUNCTION: AddExt(PSTR, PSTR);

     PURPOSE: Add default extension

 /***************************************************************************/

 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }

 /****************************************************************************

     FUNCTION: CheckFileName(HWND, PSTR, PSTR)

     PURPOSE: Check for wildcards, add extension if needed

     COMMENTS:

         Make sure you have a filename and that it does not contain any
         wildcards.  If needed, add the default extension.  This function is
         called whenever your application wants to save a file.

 ****************************************************************************/

 BOOL CheckFileName(hWnd, pDest, pSrc)
 HWND hWnd;
 PSTR pDest, pSrc;
 {
     PSTR pTmp;

     if (!pSrc[0])
         return (FALSE);               /* Indicates no filename was specified

     pTmp = pSrc;
     while (*pTmp) {                     /* Searches the string for wildcards
         switch (*pTmp++) {
             case '*':
             case '?':
                 MessageBox(hWnd, "Wildcards not allowed.",
                     NULL, MB_OK | MB_ICONEXCLAMATION);
                 return (FALSE);
         }
     }

     AddExt(pSrc, DefExt);            /* Adds the default extension if needed

     if (OpenFile(pSrc, (LPOFSTRUCT) &OfStruct, OF_EXIST) >= 0) {
         sprintf(str, "Replace existing %s?", pSrc);
         if (MessageBox(hWnd, str, "EditFile",
                 MB_OKCANCEL | MB_ICONHAND) == IDCANCEL)
             return (FALSE);
     }
     strcpy(pDest, pSrc);
     return (TRUE);
 }

 /****************************************************************************

     FUNCTION: SaveFile(HWND)

     PURPOSE: Save current file

     COMMENTS:

         This saves the current contents of the Edit buffer, and changes
         bChanges to indicate that the buffer has not been changed since the
         last save.

         Before the edit buffer is sent, you must get its handle and lock it
         to get its address.  Once the file is written, you must unlock the
         buffer.  This allows Windows to move the buffer when not in immediate
         use.

 ****************************************************************************/

 BOOL SaveFile(hWnd)
 HWND hWnd;
 {
     BOOL bSuccess;
     int IOStatus;                                  /* result of a file write

     if ((hFile = OpenFile(FileName, &OfStruct,
         OF_PROMPT | OF_CANCEL | OF_CREATE)) < 0) {

         /* If the file can't be saved */

         sprintf(str, "Cannot write to %s.", FileName);
         MessageBox(hWnd, str, NULL, MB_OK | MB_ICONEXCLAMATION);
         return (FALSE);
     }


     hEditBuffer = SendMessage(hEditWnd, EM_GETHANDLE, 0, 0L);
     pEditBuffer = LocalLock(hEditBuffer);

     /* Set the cursor to an hourglass during the file transfer */

     hSaveCursor = SetCursor(hHourGlass);
     IOStatus = write(hFile, pEditBuffer, strlen(pEditBuffer));
     close(hFile);
     SetCursor(hSaveCursor);
     if (IOStatus != strlen(pEditBuffer)) {
         sprintf(str, "Error writing to %s.", FileName);
         MessageBox(hWnd, str,
             NULL, MB_OK | MB_ICONHAND);
         bSuccess = FALSE;
     }
     else {
         bSuccess = TRUE;                /* Indicates the file was saved
         bChanges = FALSE;               /* Indicates changes have been saved
     }

     LocalUnlock(hEditBuffer);
     return (bSuccess);
 }

 /****************************************************************************

     FUNCTION: QuerySaveFile(HWND);

     PURPOSE: Called when some action might lose current contents

     COMMENTS:

         This function is called whenever we are about to take an action that
         would lose the current contents of the edit buffer.

 ****************************************************************************/

 BOOL QuerySaveFile(hWnd)
 HWND hWnd;
 {
     int Response;
     FARPROC lpSaveAsDlg;

     if (bChanges) {
         sprintf(str, "Save current changes: %s", FileName);
         Response = MessageBox(hWnd, str,
             "EditFile",  MB_YESNOCANCEL | MB_ICONEXCLAMATION);
         if (Response == IDYES) {
 check_name:

             /* Make sure there is a filename to save to */

             if (!FileName[0]) {
                 lpSaveAsDlg = MakeProcInstance(SaveAsDlg, hInst);
                 Response = DialogBox(hInst, "SaveAs",
                     hWnd, lpSaveAsDlg);
                 FreeProcInstance(lpSaveAsDlg);
                 if (Response == IDOK)
                     goto check_name;
                 else
                     return (FALSE);
             }
             SaveFile(hWnd);
         }
         else if (Response == IDCANCEL)
             return (FALSE);
     }
     else
         return (TRUE);
 }

 /****************************************************************************

     FUNCTION: SetNewBuffer(HWND, HANDLE, PSTR)

     PURPOSE: Set new buffer for edit window

     COMMENTS:

         Point the edit window to the new buffer, update the window title, and
         redraw the edit window.  If hNewBuffer is NULL, then create an empty
         1K buffer, and return its handle.

 ****************************************************************************/

 void SetNewBuffer(hWnd, hNewBuffer, Title)
 HWND hWnd;
 HANDLE hNewBuffer;
 PSTR Title;
 {
     HANDLE hOldBuffer;

     hOldBuffer = SendMessage(hEditWnd, EM_GETHANDLE, 0, 0L);
     LocalFree(hOldBuffer);
     if (!hNewBuffer)                    /* Allocates a buffer if none exists
         hNewBuffer = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, 1);

     /* Updates the buffer and displays new buffer */
     SendMessage(hEditWnd, EM_SETHANDLE, hNewBuffer, 0L);

     SetWindowText(hWnd, Title);
     SetFocus(hEditWnd);
     bChanges = FALSE;
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

         WM_INITDIALOG - initialize dialog box
         WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

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


 EDITMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\EDITMENU\EDITMENU.C

 /****************************************************************************

     PROGRAM: EditMenu.c

     PURPOSE: EditMenu template for Windows applications

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

 ****************************************************************************/

 #include "windows.h"
 #include "editmenu.h"

 HANDLE hInst;

 HANDLE hAccTable;                                /* handle to accelerator tab

 HWND   hwnd;                                    /* handle to main window */

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "EditMenuMenu";
     wc.lpszClassName = "EditMenuWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "EditMenuAcc");

     hwnd = CreateWindow(
         "EditMenuWClass",
         "EditMenu Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_DESTROY    - destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     switch (message) {
   case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 /* file menu commands */

                 case IDM_NEW:
                 case IDM_OPEN:
                 case IDM_SAVE:
                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditMenu Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:
                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "EditMenu Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;
             }
             break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 FILEOPEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\FILEOPEN\FILEOPEN.C

 /****************************************************************************

     PROGRAM: FileOpen.c

     PURPOSE: Loads, saves, and edits text files

     FUNCTIONS:

         WinMain() - calls initialization function, processes message loop
         InitApplication() - initializes window data and registers window
         InitInstance() - saves instance handle and creates main window
         MainWndProc() - processes messages
         About() - processes messages for "About" dialog box
         OpenDlg() - let user select a file, and open it.
         UpdateListBox() - Update the list box of OpenDlg
         ChangeDefExt() - Change the default extension
         SeparateFile() - Separate filename and pathname
         AddExt() - Add default extension

 ****************************************************************************/

 #include "windows.h"
 #include "fileopen.h"

 HANDLE hInst;

 HANDLE hAccTable;                                /* handle to accelerator tab
 HWND hEditWnd;                                      /* handle to edit window
 HWND hwnd;                                      /* handle to main window */

 char FileName[128];
 char PathName[128];
 char OpenName[128];
 char DefPath[128];
 char DefSpec[13] = "*.*";
 char DefExt[] = ".txt";
 char str[255];

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "FileOpenMenu";
     wc.lpszClassName = "FileOpenWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     RECT            Rect;

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "FileOpenAcc");

     hwnd = CreateWindow(
         "FileOpenWClass",
         "FileOpen Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     GetClientRect(hwnd, (LPRECT) &Rect);

     /* Create a child window */

     hEditWnd = CreateWindow("Edit",
         NULL,
         WS_CHILD | WS_VISIBLE |
         ES_MULTILINE |
         WS_VSCROLL | WS_HSCROLL |
         ES_AUTOHSCROLL | ES_AUTOVSCROLL,
         0,
         0,
         (Rect.right-Rect.left),
         (Rect.bottom-Rect.top),
         hwnd,
         IDC_EDIT,                          /* Child control i.d. */
         hInst,
         NULL);

     if (!hEditWnd) {
         DestroyWindow(hwnd);
         return (NULL);
     }

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

         WM_COMMAND    - application menu (About dialog box)
         WM_DESTROY    - destroy window

     COMMENTS:

         WM_COMMAND processing:

             IDM_OPEN - query to save current file if there is one and it
                        has been changed, open a new file.

             IDM_ABOUT - display "About" box.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpOpenDlg, lpSaveAsDlg;

     int Success;                            /* return value from SaveAsDlg()
     int IOStatus;                           /* result of file i/o      */
     int Return;

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 case IDM_OPEN:
                     /* Call OpenDlg() to get the filename */

                     lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);
                     Return = DialogBox(hInst, "Open", hWnd, lpOpenDlg);
                     FreeProcInstance(lpOpenDlg);

                     /* Let user know that "open" functionality is not yet
                        implemented */
                     if (Return)
                        MessageBox (
                              GetFocus(),
                              "Command not implemented",
                              "FileOpen Sample Application",
                              MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_NEW:
                 case IDM_SAVE:
                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "FileOpen Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:
                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "FileOpen Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "FileOpen Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SETFOCUS:
             SetFocus (hEditWnd);
             break;

         case WM_SIZE:
             MoveWindow(hEditWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
             break;

         case WM_DESTROY:
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 /****************************************************************************

     FUNCTION: OpenDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Let user select a file, and return.  Open code not provided.

 ****************************************************************************/

 HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     WORD index;
     PSTR pTptr;
     HANDLE hFile=1;     /* Temp value for return */

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDC_LISTBOX:
                     switch (HIWORD(lParam)) {

                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
                             if (DlgDirSelect(hDlg, str, IDC_LISTBOX))
                                 strcat(str, DefSpec);

                             SetDlgItemText(hDlg, IDC_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 IDC_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));
                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                     }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
                     if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) OpenName);
                         if (str[0])
                             strcpy(DefPath, str);
                         ChangeDefExt(DefExt, DefSpec);
                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     if (!OpenName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                     }

                     AddExt(OpenName, DefExt);

                     /* The routine to open the file would go here, and the */
                     /* file handle would be returned instead of NULL.
                     EndDialog(hDlg, hFile);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }

 /****************************************************************************

     FUNCTION: UpdateListBox(HWND);

     PURPOSE: Update the list box of OpenDlg

 ****************************************************************************/

 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* To ensure that the listing is made for a subdir. of
      * current drive dir...
      */
     if (!strchr (DefPath, ':'))
   DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* Remove the '..' character from path if it exists, since this
      * will make DlgDirList move us up an additional level in the tree
      * when UpdateListBox() is called again.
      */
     if (strstr (DefPath, ".."))
   DefPath[0] = '\0';

     SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
 }

 /****************************************************************************

     FUNCTION: ChangeDefExt(PSTR, PSTR);

     PURPOSE: Change the default extension

 ****************************************************************************/

 void ChangeDefExt(Ext, Name)
 PSTR Ext, Name;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr)
         if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
             strcpy(Ext, pTptr);
 }

 /****************************************************************************

     FUNCTION: SeparateFile(HWND, LPSTR, LPSTR, LPSTR)

     PURPOSE: Separate filename and pathname

 ****************************************************************************/

 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;
     char  cTmp;

     lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {
         lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     lstrcpy(lpDestFileName, lpTmp + 1);
     cTmp = *(lpTmp + 1);
     lstrcpy(lpDestPath, lpSrcFileName);
      *(lpTmp + 1) = cTmp;
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }

 /****************************************************************************

     FUNCTION: AddExt(PSTR, PSTR);

     PURPOSE: Add default extension

 /***************************************************************************/

 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }

 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

         WM_INITDIALOG - initialize dialog box
         WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

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


 GENERIC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\GENERIC\GENERIC.C

 /****************************************************************************

     PROGRAM: Generic.c

     PURPOSE: Generic template for Windows applications

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

     COMMENTS:

         Windows can have several copies of your application running at the
         same time.  The variable hInst keeps track of which instance this
         application is so that processing will be to the correct window.

 ****************************************************************************/

  "windows.h"        /* required for all Windows applications */
  "generic.h"        /* specific to this program         */

 HANDLE hInst;          /* current instance           */

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

     COMMENTS:

         Windows recognizes this function by name as the initial entry point
         for the program.  This function calls the application initialization
         routine, if no other instance of the program is running, and always
         calls the instance initialization routine.  It then executes a messag
         retrieval and dispatch loop that is the top-level control structure
         for the remainder of execution.  The loop is terminated when a WM_QUI
         message is received, at which time this function exits the applicatio
         instance by returning the value passed by PostQuitMessage().

         If this function must abort before entering the message loop, it
         returns the conventional value NULL.

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;           /* current instance       */
 HANDLE hPrevInstance;           /* previous instance       */
 LPSTR lpCmdLine;           /* command line         */
 int nCmdShow;             /* show-window type (open/icon) */
 {
     MSG msg;             /* message           */

     if (!hPrevInstance)       /* Other instances of app running? */
   if (!InitApplication(hInstance)) /* Initialize shared things */
       return (FALSE);     /* Exits if unable to initialize     */

     /* Perform initializations that apply to a specific instance */

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     /* Acquire and dispatch messages until a WM_QUIT message is received. */

     while (GetMessage(&msg,     /* message structure           */
       NULL,       /* handle of window receiving the message */
       NULL,       /* lowest message to examine         */
       NULL))       /* highest message to examine       */
   {
   TranslateMessage(&msg);     /* Translates virtual key codes       */
   DispatchMessage(&msg);     /* Dispatches message to window       */
     }
     return (msg.wParam);     /* Returns the value from PostQuitMessage */
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

     COMMENTS:

         This function is called at initialization time only if no other
         instances of the application are running.  This function performs
         initialization tasks that can be done once for any number of running
         instances.

         In this case, we initialize a window class by filling out a data
         structure of type WNDCLASS and calling the Windows RegisterClass()
         function.  Since all instances of this application use the same windo
         class, we only need to do this when the first instance is initialized


 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;             /* current instance       */
 {
     WNDCLASS  wc;

     /* Fill in window class structure with parameters that describe the
     /* main window.

     wc.style = NULL;                    /* Class style(s).
     wc.lpfnWndProc = MainWndProc;       /* Function to retrieve messages for
                                         /* windows of this class.
     wc.cbClsExtra = 0;                  /* No per-class extra data.
     wc.cbWndExtra = 0;                  /* No per-window extra data.
     wc.hInstance = hInstance;           /* Application that owns the class.
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "GenericMenu";   /* Name of menu resource in .RC file.
     wc.lpszClassName = "GenericWClass"; /* Name used in call to CreateWindow.

     /* Register the window class and return success/failure code. */

     return (RegisterClass(&wc));

 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

     COMMENTS:

         This function is called at initialization time for every instance of
         this application.  This function performs initialization tasks that
         cannot be shared by multiple instances.

         In this case, we save the instance handle in a static variable and
         create and display the main program window.

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;          /* Current instance identifier.
     int             nCmdShow;           /* Param for first ShowWindow() call.
 {
     HWND            hWnd;               /* Main window handle.

     /* Save the instance handle in static variable, which will be used in  */
     /* many subsequence calls from this application to Windows.            */

     hInst = hInstance;

     /* Create a main window for this application instance.  */

     hWnd = CreateWindow(
         "GenericWClass",                /* See RegisterClass() call.
         "Generic Sample Application",   /* Text for window title bar.
         WS_OVERLAPPEDWINDOW,            /* Window style.
         CW_USEDEFAULT,                  /* Default horizontal position.
         CW_USEDEFAULT,                  /* Default vertical position.
         CW_USEDEFAULT,                  /* Default width.
         CW_USEDEFAULT,                  /* Default height.
         NULL,                           /* Overlapped windows have no parent.
         NULL,                           /* Use the window class menu.
         hInstance,                      /* This instance owns this window.
         NULL                            /* Pointer not needed.
     );

     /* If window could not be created, return "failure" */

     if (!hWnd)
         return (FALSE);

     /* Make the window visible; update its client area; and return "success"

     ShowWindow(hWnd, nCmdShow);  /* Show the window                        */
     UpdateWindow(hWnd);          /* Sends WM_PAINT message                 */
     return (TRUE);               /* Returns the value from PostQuitMessage */

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_DESTROY    - destroy window

     COMMENTS:

   To process the IDM_ABOUT message, call MakeProcInstance() to get the
   current instance address of the About() function.  Then call Dialog
   box which will create the box according to the information in your
   generic.rc file and turn control over to the About() function.  When
   it returns, free the intance address.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;          /* window handle         */
 unsigned message;        /* type of message         */
 WORD wParam;          /* additional information       */
 LONG lParam;          /* additional information       */
 {
     FARPROC lpProcAbout;      /* pointer to the "About" function */

     switch (message) {
   case WM_COMMAND:     /* message: command from application menu */
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,     /* current instance       */
         "AboutBox",       /* resource to use       */
         hWnd,       /* parent handle       */
         lpProcAbout);     /* About() instance address */

     FreeProcInstance(lpProcAbout);
     break;
       }
       else          /* Lets Windows process it       */
     return (DefWindowProc(hWnd, message, wParam, lParam));

   case WM_DESTROY:      /* message: window being destroyed */
       PostQuitMessage(0);
       break;

   default:        /* Passes it on if unproccessed    */
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

     COMMENTS:

   No initialization is needed for this particular dialog box, but TRUE
   must be returned to Windows.

   Wait for user to click on "Ok" button, then close the dialog box.

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;                                /* window handle of the dialog box
 unsigned message;                         /* type of message
 WORD wParam;                              /* message-specific information
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:       /* message: initialize dialog box */
       return (TRUE);

   case WM_COMMAND:          /* message: received a command */
       if (wParam == IDOK                /* "OK" box selected?       */
                 || wParam == IDCANCEL) {      /* System menu close command? *
     EndDialog(hDlg, TRUE);        /* Exits the dialog box       */
     return (TRUE);
       }
       break;
     }
     return (FALSE);            /* Didn't process a message    */
 }


 HELPEX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\HELPEX\HELPEX.C

 /****************************************************************************

    PROGRAM:    HelpEx.c

    PURPOSE:    Illustrates calls to WinHelp and context-sensitive help.
                HelpEx loads library MenuHook, which detects F1 keystrokes in
                the HelpEx application menus.

    FUNCTIONS:

    WinMain() - Calls initialization function, processes message loop.
    InitApplication() - Initializes window data and registers window class.
    InitInstance() - Saves instance handle and creates main window.
    MainWndProc() - Processes window messages.
    About() - Processes messages for "About" dialog box.
    MakeHelpPathName() - Derives path name of help file.

 ****************************************************************************/

 #include <windows.h>
 #include "helpex.h"
 #include "helpids.h"

 HWND       hWnd;               /* Handle to main window */
 HANDLE     hInst;              /* Handle to instance data*/
 BOOL       bHelp = FALSE;      /* Help mode flag; TRUE = "ON"*/
 HCURSOR    hHelpCursor;        /* Cursor displayed when in help mode*/
 char       szHelpFileName[EXE_NAME_MAX_SIZE+1];    /* Help file name*/
 HANDLE     hAccTable;                              /* handle to accelerator t

 void MakeHelpPathName(char*);  /* Function deriving help file path */


 /****************************************************************************

    FUNCTION:   WinMain(HANDLE, HANDLE, LPSTR, int)

    PURPOSE:    Calls initialization function, processes message loop.

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpCmdLine;
 int    nCmdShow;
 {
    MSG msg;

    if (!hPrevInstance)
        if (!InitApplication(hInstance))
        return (FALSE);

    if (!InitInstance(hInstance, nCmdShow))
        return (FALSE);

    while (GetMessage(&msg, NULL, NULL, NULL)) {

       /* Only translate message if it is not an accelerator message */
       if (!TranslateAccelerator(hWnd, hAccTable, &msg)) {

           TranslateMessage(&msg);
           DispatchMessage(&msg);
       }
    }
    return (msg.wParam);
 }


 /****************************************************************************

    FUNCTION:   InitApplication(HANDLE)

    PURPOSE:    Initializes window data and registers window class.

    RETURNS:    Status of RegisterClass() call.

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
    WNDCLASS wc;

    wc.style = NULL;
    wc.lpfnWndProc = MainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName ="HelpexMenu";
    wc.lpszClassName = "HelpexWClass";

    return (RegisterClass(&wc));
 }


 /****************************************************************************

    FUNCTION:   InitInstance(HANDLE, int)

    PURPOSE:    Saves instance handle in global variable and creates main
                window.

    RETURNS:    Status of CreateWindow() call.

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
 HANDLE hInstance;
 int    nCmdShow;
 {

    hInst = hInstance;

    hAccTable = LoadAccelerators(hInst, "HelpexAcc");

    hWnd = CreateWindow(
        "HelpexWClass",
        "Help Example ",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        NULL,
        NULL,
        hInstance,
        NULL
        );

    if (!hWnd)
        return (FALSE);

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

    EnableMenuItem(GetSubMenu(GetMenu(hWnd), 1), IDM_CLEAR, MF_ENABLED);

    MakeHelpPathName(szHelpFileName);
    hHelpCursor = LoadCursor(hInst,"HelpCursor");

    return (TRUE);

 }

 /****************************************************************************

    FUNCTION:   MainWndProc(HWND, unsigned, WORD, LONG)

    PURPOSE:    Processes window messages.

    MESSAGES:

        WM_COMMAND- Application menu item
        WM_DESTROY- Destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND       hWnd;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
 {
    FARPROC lpProcAbout;
    DWORD   dwHelpContextId;
    RECT    rect;
    POINT   pt;
    DWORD   dword;
    WORD    wFormat;
    HCURSOR hArrow;

    switch (message) {

        case WM_COMMAND:
            /* Was F1 just pressed in a menu, or are we in help mode */
            /* (Shift-F1)? */

            if (bHelp) {
                dwHelpContextId =
                    (wParam == IDM_NEW)    ? (DWORD) HELPID_FILE_NEW     :
                    (wParam == IDM_OPEN)   ? (DWORD) HELPID_FILE_OPEN    :
                    (wParam == IDM_SAVE)   ? (DWORD) HELPID_FILE_SAVE    :
                    (wParam == IDM_SAVEAS) ? (DWORD) HELPID_FILE_SAVE_AS :
                    (wParam == IDM_PRINT)  ? (DWORD) HELPID_FILE_PRINT   :
                    (wParam == IDM_EXIT)   ? (DWORD) HELPID_FILE_EXIT    :
                    (wParam == IDM_UNDO)   ? (DWORD) HELPID_EDIT_UNDO    :
                    (wParam == IDM_CUT)    ? (DWORD) HELPID_EDIT_CUT     :
                    (wParam == IDM_CLEAR)  ? (DWORD) HELPID_EDIT_CLEAR   :
                    (wParam == IDM_COPY)   ? (DWORD) HELPID_EDIT_COPY    :
                    (wParam == IDM_PASTE)  ? (DWORD) HELPID_EDIT_PASTE   :
                                             (DWORD) 0L;

                if (!dwHelpContextId)
          {
                    MessageBox( hWnd, "Help not available for Help Menu item",
              "Help Example", MB_OK                          );
                    return (DefWindowProc(hWnd, message, wParam, lParam));
          }

                bHelp = FALSE;
                WinHelp(hWnd,szHelpFileName,HELP_CONTEXT,dwHelpContextId);
                break;
            }

            switch (wParam) {
                case IDM_NEW:
                case IDM_OPEN:
                case IDM_SAVE:
                case IDM_SAVEAS:
                case IDM_PRINT:
                case IDM_UNDO:
                case IDM_CUT:
                case IDM_CLEAR:
                case IDM_COPY:
                case IDM_PASTE:
                    MessageBox(hWnd,
                    "Command not implemented",
                    "Help Example",
                    MB_OK);
                    break;

                case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                case IDM_HELP_INDEX:
                    WinHelp(hWnd,szHelpFileName,HELP_INDEX,0L);
                    break;

                case IDM_HELP_KEYBOARD:
        WinHelp(hWnd,szHelpFileName,HELP_KEY,(DWORD)(LPSTR)"keys");
                    break;

                case IDM_HELP_HELP:
        WinHelp(hWnd,"WINHELP.HLP",HELP_INDEX,0L);
                    break;

                case IDM_ABOUT:
                    lpProcAbout = MakeProcInstance(About, hInst);
                    DialogBox(hInst,
                        "AboutBox",
                        hWnd,
                        lpProcAbout);
                    FreeProcInstance(lpProcAbout);
                    break;

                default:
                    return (DefWindowProc(hWnd, message, wParam, lParam));
            }

            break;

        case WM_LBUTTONDOWN:
      if (bHelp)
      {
          bHelp = FALSE;
          WinHelp( hWnd, szHelpFileName, HELP_CONTEXT,
       (DWORD) HELPID_EDIT_WINDOW          );
          break;
      }

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

        case WM_NCLBUTTONDOWN:
            /* If we are in help mode (Shift-F1) then display context- */
            /* sensitive help for non-client area. */

            if (bHelp) {
                dwHelpContextId =
                    (wParam == HTCAPTION)     ? (DWORD) HELPID_TITLE_BAR     :
                    (wParam == HTREDUCE)      ? (DWORD) HELPID_MINIMIZE_ICON :
                    (wParam == HTZOOM)        ? (DWORD) HELPID_MAXIMIZE_ICON :
                    (wParam == HTSYSMENU)     ? (DWORD) HELPID_SYSTEM_MENU   :
                    (wParam == HTBOTTOM)      ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTBOTTOMLEFT)  ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTBOTTOMRIGHT) ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTTOP)         ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTLEFT)        ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTRIGHT)       ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTTOPLEFT)     ? (DWORD) HELPID_SIZING_BORDER :
                    (wParam == HTTOPRIGHT)    ? (DWORD) HELPID_SIZING_BORDER :
                                                (DWORD) 0L;

                if (!((BOOL)dwHelpContextId))
                    return (DefWindowProc(hWnd, message, wParam, lParam));

                bHelp = FALSE;
                WinHelp(hWnd,szHelpFileName,HELP_CONTEXT,dwHelpContextId);
                break;
            }

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

        case WM_KEYDOWN:
            if (wParam == VK_F1) {

                /* If Shift-F1, turn help mode on and set help cursor */

                if (GetKeyState(VK_SHIFT)<0) {
                    bHelp = TRUE;
                    SetCursor(hHelpCursor);
                    return (DefWindowProc(hWnd, message, wParam, lParam));
                }

                /* If F1 without shift, then call up help main index topic */
                else {
                    WinHelp(hWnd,szHelpFileName,HELP_INDEX,0L);
                }
            }

            else if (wParam == VK_ESCAPE && bHelp) {

                /* Escape during help mode: turn help mode off */
                bHelp = FALSE;
                SetCursor((HCURSOR)GetClassWord(hWnd,GCW_HCURSOR));
            }

            break;

        case WM_SETCURSOR:
            /* In help mode it is necessary to reset the cursor in response */
            /* to every WM_SETCURSOR message.Otherwise, by default, Windows */
            /* will reset the cursor to that of the window class. */

            if (bHelp) {
                SetCursor(hHelpCursor);
                break;
            }
            return (DefWindowProc(hWnd, message, wParam, lParam));
            break;

        case WM_INITMENU:
            if (bHelp) {
                SetCursor(hHelpCursor);
            }
            return (TRUE);

        case WM_ENTERIDLE:
            if ((wParam == MSGF_MENU) && (GetKeyState(VK_F1) & 0x8000)) {
                bHelp = TRUE;
                PostMessage(hWnd, WM_KEYDOWN, VK_RETURN, 0L);
            }
            break;

        case WM_DESTROY:
            WinHelp(hWnd,szHelpFileName,HELP_QUIT,0L);
            PostQuitMessage(0);
            break;

        default:
            return (DefWindowProc(hWnd, message, wParam, lParam));
    }

    return (NULL);
 }


 /****************************************************************************

    FUNCTION:   About(HWND, unsigned, WORD, LONG)

    PURPOSE:    Processes messages for "About" dialog box

    MESSAGES:

        WM_INITDIALOG - Initialize dialog box
        WM_COMMAND- Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND       hDlg;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
 {
    switch (message) {
        case WM_INITDIALOG:
            return (TRUE);

        case WM_COMMAND:
            if (wParam == IDOK) {
                EndDialog(hDlg, TRUE);
                return (TRUE);
            }
            break;
    }

    return (FALSE);
 }


 /****************************************************************************

    FUNCTION:   MakeHelpPathName

    PURPOSE:    HelpEx assumes that the .HLP help file is in the same
                directory as the HelpEx executable.This function derives
                the full path name of the help file from the path of the
                executable.

 ****************************************************************************/

 void MakeHelpPathName(szFileName)
 char * szFileName;
 {
    char *  pcFileName;
    int     nFileNameLen;

    nFileNameLen = GetModuleFileName(hInst,szFileName,EXE_NAME_MAX_SIZE);
    pcFileName = szFileName + nFileNameLen;

    while (pcFileName > szFileName) {
        if (*pcFileName == '\\' || *pcFileName == ':') {
            *(++pcFileName) = '\0';
            break;
        }
    nFileNameLen--;
    pcFileName--;
    }

    if ((nFileNameLen+13) < EXE_NAME_MAX_SIZE) {
        lstrcat(szFileName, "helpex.hlp");
    }

    else {
        lstrcat(szFileName, "?");
    }

    return;
 }


 ICON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\ICON\ICON.C

 /****************************************************************************

     PROGRAM: Icon.c

     PURPOSE: Demonstrates using an icon for the About box and minimize box

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

 ****************************************************************************/

 #include "windows.h"
 #include "icon.h"

 HANDLE hInst;

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(hInstance, "MyIcon");           /* loads icon */
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "IconMenu";
     wc.lpszClassName = "IconWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hWnd;

     hInst = hInstance;

     hWnd = CreateWindow(
         "IconWClass",
         "Icon Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hWnd)
         return (FALSE);

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

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_DESTROY    - destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     switch (message) {
   case WM_COMMAND:
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,
         "AboutBox",
         hWnd,
         lpProcAbout);

     FreeProcInstance(lpProcAbout);
     break;
       }
       else
     return (DefWindowProc(hWnd, message, wParam, lParam));

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 INPUT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\INPUT\INPUT.C

 /****************************************************************************

     PROGRAM: Input.c

     PURPOSE: Input template for Windows applications

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

 ****************************************************************************/

 #include "windows.h"
 #include "input.h"

 HANDLE hInst;

 char MouseText[48];                                   /* mouse state
 char ButtonText[48];                                  /* mouse-button state
 char KeyboardText[48];                                /* keyboard state
 char CharacterText[48];                               /* latest character
 char ScrollText[48];                                  /* scroll status
 char TimerText[48];                                   /* timer state
 RECT rectMouse;
 RECT rectButton;
 RECT rectKeyboard;
 RECT rectCharacter;
 RECT rectScroll;
 RECT rectTimer;
 int idTimer;                                          /* timer ID
 int nTimerCount = 0;                                  /* current timer count

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = CS_DBLCLKS;          /* double-click messages */
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "InputMenu";
     wc.lpszClassName = "InputWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hWnd;
     HDC             hDC;
     TEXTMETRIC      textmetric;
     RECT            rect;
     int             nLineHeight;


     hInst = hInstance;

     hWnd = CreateWindow(
         "InputWClass",
         "Input Sample Application",
         WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,  /* horz & vert scroll
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hWnd)
         return (FALSE);


     hDC = GetDC(hWnd);
     GetTextMetrics(hDC, &textmetric);
     ReleaseDC(hWnd, hDC);
     nLineHeight = textmetric.tmExternalLeading + textmetric.tmHeight;

     rect.left   = GetDeviceCaps(hDC, LOGPIXELSX) / 4;   /* 1/4 inch */
     rect.right  = GetDeviceCaps(hDC, HORZRES);
     rect.top    = GetDeviceCaps(hDC, LOGPIXELSY) / 4;   /* 1/4 inch */
     rect.bottom = rect.top + nLineHeight;
     rectMouse   = rect;

     rect.top += nLineHeight;
     rect.bottom += nLineHeight;
     rectButton = rect;

     rect.top += nLineHeight;
     rect.bottom += nLineHeight;
     rectKeyboard = rect;

     rect.top += nLineHeight;
     rect.bottom += nLineHeight;
     rectCharacter = rect;

     rect.top += nLineHeight;
     rect.bottom += nLineHeight;
     rectScroll = rect;

     rect.top += nLineHeight;
     rect.bottom += nLineHeight;
     rectTimer = rect;

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

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_CREATE     - create window
         WM_MOUSEMOVE  - mouse movement
         WM_LBUTTONDOWN - left mouse button pressed
         WM_LBUTTONUP  - left mouse button released
         WM_LBUTTONDBLCLK - left mouse button double clicked
         WM_KEYDOWN    - key pressed
         WM_KEYUP      - key released
         WM_CHAR       - ASCII character received
         WM_TIMER      - timer has elapsed
         WM_HSCROLL    - mouse click in horizontal scroll bar
         WM_VSCROLL    - mouse click in vertical scroll bar
         WM_PAINT      - update window, draw objects
         WM_DESTROY    - destroy window

     COMMENTS:

         This demonstrates how input messages are received, and what the
         additional information is that comes with the message.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     HDC hDC;                         /* display-context variable     */
     PAINTSTRUCT ps;                  /* paint structure              */
     char HorzOrVertText[12];
     char ScrollTypeText[20];
     RECT rect;

     switch (message) {
   case WM_COMMAND:
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,
         "AboutBox",
         hWnd,
         lpProcAbout);

     FreeProcInstance(lpProcAbout);
     break;
       }
       else
     return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CREATE:

             /* Set the timer for five-second intervals */

             idTimer =  SetTimer(hWnd, NULL, 5000, (FARPROC) NULL);

             break;

         case WM_MOUSEMOVE:
             wsprintf(MouseText, "WM_MOUSEMOVE: %x, %d, %d",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectMouse, TRUE);
             break;

         case WM_LBUTTONDOWN:
             wsprintf(ButtonText, "WM_LBUTTONDOWN: %x, %d, %d",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectButton, TRUE);
             break;

         case WM_LBUTTONUP:
             wsprintf(ButtonText, "WM_LBUTTONUP: %x, %d, %d",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectButton, TRUE);
             break;

         case WM_LBUTTONDBLCLK:
             wsprintf(ButtonText, "WM_LBUTTONDBLCLK: %x, %d, %d",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectButton, TRUE);
             break;

         case WM_KEYDOWN:
             wsprintf(KeyboardText, "WM_KEYDOWN: %x, %x, %x",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectKeyboard, TRUE);
             break;

         case WM_KEYUP:
             wsprintf(KeyboardText, "WM_KEYUP: %x, %x, %x",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectKeyboard, TRUE);
             break;

         case WM_CHAR:
             wsprintf(CharacterText, "WM_CHAR: %c, %x, %x",
                 wParam, LOWORD(lParam), HIWORD(lParam));
             InvalidateRect(hWnd, &rectCharacter, TRUE);
             break;

         case WM_TIMER:
             wsprintf(TimerText, "WM_TIMER: %d seconds",
                 nTimerCount += 5);
             InvalidateRect(hWnd, &rectTimer, TRUE);
             break;

         case WM_HSCROLL:
         case WM_VSCROLL:
             strcpy(HorzOrVertText,
                 (message == WM_HSCROLL) ? "WM_HSCROLL" : "WM_VSCROLL");
             strcpy(ScrollTypeText,
                 (wParam == SB_LINEUP) ? "SB_LINEUP" :
                 (wParam == SB_LINEDOWN) ? "SB_LINEDOWN" :
                 (wParam == SB_PAGEUP) ? "SB_PAGEUP" :
                 (wParam == SB_PAGEDOWN) ? "SB_PAGEDOWN" :
                 (wParam == SB_THUMBPOSITION) ? "SB_THUMBPOSITION" :
                 (wParam == SB_THUMBTRACK) ? "SB_THUMBTRACK" :
                 (wParam == SB_ENDSCROLL) ? "SB_ENDSCROLL" : "unknown");
             wsprintf(ScrollText, "%s: %s, %x, %x",
                 (LPSTR)HorzOrVertText,
                 (LPSTR)ScrollTypeText,
                 LOWORD(lParam),
                 HIWORD(lParam));
             InvalidateRect(hWnd, &rectScroll, TRUE);
             break;

         case WM_PAINT:
             hDC = BeginPaint (hWnd, &ps);

             if (IntersectRect(&rect, &rectMouse, &ps.rcPaint))
                 TextOut(hDC, rectMouse.left, rectMouse.top,
                         MouseText, strlen(MouseText));
             if (IntersectRect(&rect, &rectButton, &ps.rcPaint))
                 TextOut(hDC, rectButton.left, rectButton.top,
                         ButtonText, strlen(ButtonText));
             if (IntersectRect(&rect, &rectKeyboard, &ps.rcPaint))
                 TextOut(hDC, rectKeyboard.left, rectKeyboard.top,
                         KeyboardText, strlen(KeyboardText));
             if (IntersectRect(&rect, &rectCharacter, &ps.rcPaint))
                 TextOut(hDC, rectCharacter.left, rectCharacter.top,
                         CharacterText, strlen(CharacterText));
             if (IntersectRect(&rect, &rectTimer, &ps.rcPaint))
                 TextOut(hDC, rectTimer.left, rectTimer.top,
                         TimerText, strlen(TimerText));
             if (IntersectRect(&rect, &rectScroll, &ps.rcPaint))
                 TextOut(hDC, rectScroll.left, rectScroll.top,
                         ScrollText, strlen(ScrollText));

             EndPaint(hWnd, &ps);
             break;

         case WM_DESTROY:
             KillTimer(hWnd, idTimer);                     /* Stops the timer
             PostQuitMessage(0);
             break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 MEMORY1.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MEMORY\MEMORY1.C

 #include "windows.h"
 #include "memory.h"

 HANDLE hInst;

 /****************************************************************************
     MODULE:  memory1.c

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 MEMORY2.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MEMORY\MEMORY2.C

 #include "windows.h"
 #include "memory.h"

 /****************************************************************************
     MODULE:  memory2.c

     FUNCTION: MemoryInit(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "MemoryMenu";
     wc.lpszClassName = "MemoryWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************
     MODULE:  memory3.c


     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hwnd;

     hInst = hInstance;

     hwnd = CreateWindow(
         "MemoryWClass",
         "Memory Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }


 MEMORY3.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MEMORY\MEMORY3.C

 #include "windows.h"
 #include "memory.h"

 /****************************************************************************
     MODULE:  memory3.c

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_DESTROY    - destroy window

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     switch (message) {
   case WM_COMMAND:
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,
         "AboutBox",
         hWnd,
         lpProcAbout);

     FreeProcInstance(lpProcAbout);
     break;
       }
       else
     return (DefWindowProc(hWnd, message, wParam, lParam));

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 MEMORY4.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MEMORY\MEMORY4.C

 #include "windows.h"
 #include "memory.h"

 /****************************************************************************
     MODULE:  memory4.c

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 MENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MENU\MENU.C

 /***************************************************************************
  *                     *
  *  PROGRAM  : Menu.c               *
  *                     *
  *  PURPOSE  : To give a demonstration of the use of popup menus, user  *
  *      defined menus and menu functions.         *
  *                     *
  *  FUNCTIONS  : WinMain()        - Calls the initialization function  *
  *          and enters the message loop.     *
  *                     *
  *      MenuInit()        - Registers the app. window class.   *
  *                     *
  *      About()        - Dialog function for the About..    *
  *          dialog.          *
  *                     *
  *      ShrinkBitmap()      - Shrinks a 64x64 bitmap to a size   *
  *          useable for a user-defined menu    *
  *          checkmark.         *
  *                     *
  *      HandleCreate()      - Creates a new menu and appends it  *
  *          to the main menu       *
  *                     *
  *      HandlePaint()       - Handles repainting the app's client*
  *          area           *
  *                     *
  *      HandleChangeColors()- Changes the state of the "colors"  *
  *          menu item.         *
  *                     *
  *      HandleDrawItem()    - Redraws the menu items in the     *
  *          "colors" menu         *
  *                     *
  *      HandlePopupMenu()   - handles display of the "floating"  *
  *          popup.           *
  *                     *
  *      MenuWndProc()       - Window function for the app.     *
  *                     *
  *                     *
  ***************************************************************************/
 #include "windows.h"
 #include "menu.h"

 HANDLE   hInst;
 HMENU   hBigMenu;
 HBITMAP  hbmCheckOn;
 HBITMAP  hbmCheckOff;

 /****************************************************************************
  *                      *
  *  FUNCTION   : WinMain(HANDLE, HANDLE, LPSTR, int)          *
  *                      *
  *  PURPOSE    : Creates the main app. window, calls an initialization      *
  *     function and enters the message loop.          *
  *                      *
  ****************************************************************************
 int PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;

 {
     HWND  hWnd;
     MSG   msg;

     /* Register main window class if this is the first instance of the app. *
     if (!hPrevInstance)
   if (!MenuInit (hInstance))
       return NULL;

     hInst = hInstance;

     /* Create the app. window */
     hWnd = CreateWindow ("menu",
        "Menu Example",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        (HWND) NULL,
        NULL,
        hInstance,
        (LPSTR) NULL);

     if (!hWnd)
   return NULL;

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

     while (GetMessage (&msg, NULL, NULL, NULL)){
   /* Since we have no accelerators, no need to call
    * TranslateAccelerator here.
    */
   TranslateMessage (&msg);
   DispatchMessage (&msg);
     }
     return(msg.wParam);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : MenuInit (hInstance)              *
  *                      *
  *  PURPOSE    : Registers the main window class.          *
  *                      *
  *  RETURNS    : TRUE  -  if RegisterClass() went off ok        *
  *     FALSE  -  otherwise.              *
  *                      *
  ****************************************************************************
 BOOL NEAR PASCAL MenuInit (hInstance)

 HANDLE hInstance;

 {
     HANDLE    hMemory;
     PWNDCLASS pWndClass;
     BOOL      bSuccess;

     /* Initialize the menu window class */
     hMemory   = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style       = NULL;
     pWndClass->lpfnWndProc   = MenuWndProc;
     pWndClass->hInstance     = hInstance;
     pWndClass->hIcon       = LoadIcon (hInstance, "menu");
     pWndClass->hCursor       = LoadCursor (NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH);
     pWndClass->lpszMenuName  = (LPSTR) "MenuMenu",
     pWndClass->lpszClassName = (LPSTR) "menu";

     bSuccess = RegisterClass (pWndClass);
     LocalUnlock (hMemory);
     LocalFree (hMemory);

     return bSuccess;
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : About (hDlg, message, wParam, lParam)          *
  *                      *
  *  PURPOSE    : Dialog function for the About menu... dialog.        *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)

 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;

 {
     switch (message){
   case WM_INITDIALOG:
       return(TRUE);

   case WM_COMMAND:
       if (wParam == IDOK){
     EndDialog(hDlg,NULL);
     return(TRUE);
       }
       break;
     }
     return(FALSE);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : ShrinkBitmap(hwnd, hbm)            *
  *                      *
  *  PURPOSE    : This function shrinks a 64x64 bitmap into a bitmap useable *
  *     for the user-defined checkmark for menu items. This can be *
  *     easily generalized to shrink bitmaps of any size.      *
  *                      *
  *  RETURNS    : HBITMAP - A handle to the new bitmap.          *
  *                      *
  ****************************************************************************
 HBITMAP FAR PASCAL ShrinkBitmap (hwnd, hbm)

 HWND hwnd;
 HBITMAP hbm;

 {
     HDC     hdc;
     HDC     hmemorydcNew;
     HDC     hmemorydcOld;
     LONG    checkMarkSize;
     HBITMAP hCheckBitmap;
     HBITMAP hOldBitmapSave;
     HBITMAP hNewBitmapSave;

     hdc = GetDC (hwnd);

     /* Create DCs for the source (old) and target (new) bitmaps */
     hmemorydcNew = CreateCompatibleDC (hdc);
     hmemorydcOld = CreateCompatibleDC (hdc);

     /* Determine the dimensions of the default menu checkmark and
      * create a target bitmap of the same dimensions
      */
     checkMarkSize = GetMenuCheckMarkDimensions ();
     hCheckBitmap  = CreateCompatibleBitmap (hdc,
               LOWORD (checkMarkSize),
               HIWORD (checkMarkSize));

     /* Select the source bitmap and the target bitmap into their
      * respective DCs.
      */
     hOldBitmapSave = SelectObject (hmemorydcNew, hCheckBitmap);
     hNewBitmapSave = SelectObject (hmemorydcOld, hbm);

     /* Shrink the source bitmap into the target DC */
     StretchBlt (hmemorydcNew,
     0,
     0,
     LOWORD(checkMarkSize),
     HIWORD(checkMarkSize),
     hmemorydcOld,
     0,
     0,
     64,
     64,
     SRCCOPY);

     /* De-select the bitmaps and clean up .. */
     SelectObject (hmemorydcNew, hOldBitmapSave);
     SelectObject (hmemorydcOld, hNewBitmapSave);
     DeleteDC (hmemorydcNew);
     DeleteDC (hmemorydcOld);
     ReleaseDC (hwnd, hdc);

     /* .. and return a handle to the target bitmap */
     return hCheckBitmap;
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : HandleCreate ( hwnd )              *
  *                      *
  *  PURPOSE    : Creates a new (empty) menu and appends to it the "State"   *
  *     menu items. It sets up the user-defined checkmarks for the *
  *     menu. It then inserts this menu into the main menu bar.    *
  *                      *
  ****************************************************************************
 void FAR PASCAL HandleCreate (hwnd)
 HWND hwnd;
 {
     HMENU   hMenu;
     HMENU   hWndMenu;
     HBITMAP hbmOn;
     HBITMAP hbmOff;

     /* Create a new menu into the menubar on the fly */
     hMenu = CreateMenu ();
     if (!hMenu)
   return;

     /* Append the state menu items to it */
     AppendMenu (hMenu, MF_STRING, IDM_STATE1, "South Dakota");
     AppendMenu (hMenu, MF_STRING, IDM_STATE2, "Washington");
     AppendMenu (hMenu, MF_STRING, IDM_STATE3, "California");
     if (!AppendMenu (hMenu, MF_STRING, IDM_STATE4, "Oregon")){
   /* It is unlikely the other appends will fail and this will succeed.
    * So just check this one. And if it fails, Destroy the menu for
    * good measure and return.
    */
   DestroyMenu(hMenu);
   return;
     }
     hbmCheckOn  = ShrinkBitmap (hwnd, LoadBitmap (hInst, "checkon"));
     hbmCheckOff = ShrinkBitmap (hwnd, LoadBitmap (hInst, "checkoff"));

     /* Set up the user-defined check marks */
     SetMenuItemBitmaps (hMenu, 0, MF_BYPOSITION, hbmCheckOff, hbmCheckOn);
     SetMenuItemBitmaps (hMenu, 1, MF_BYPOSITION, hbmCheckOff, hbmCheckOn);
     SetMenuItemBitmaps (hMenu, 2, MF_BYPOSITION, hbmCheckOff, hbmCheckOn);
     SetMenuItemBitmaps (hMenu, 3, MF_BYPOSITION, hbmCheckOff, hbmCheckOn);

     /* Now insert the menu into the main menu bar. */
     hWndMenu = GetMenu (hwnd);
     InsertMenu (hWndMenu, 2, MF_POPUP|MF_BYPOSITION, (WORD)hMenu, "States");

     return;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : HandlePaint ( hwnd )              *
  *                      *
  *  PURPOSE    : Handles the repainting of the main app's client area.      *
  *                      *
  ****************************************************************************
 void FAR PASCAL HandlePaint (hwnd)
 HWND hwnd;
 {
     HDC   hdc;
     PAINTSTRUCT ps;
     RECT  rc;

     hdc = BeginPaint (hwnd, (LPPAINTSTRUCT)&ps);

     /* Center the text in the client area */
     GetClientRect (hwnd, (LPRECT)&rc);
     DrawText (hdc,
         "Down click in the window for a popup menu",
          41,
          (LPRECT)&rc,
          DT_CENTER | DT_WORDBREAK);
     EndPaint(hwnd, (LPPAINTSTRUCT)&ps);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : HandleChangeColors (hwnd)            *
  *                      *
  *  PURPOSE    : Toggles the state of the Owner Draw item in the Colors     *
  *     menu. If it is on, the "Black", "Blue", "Red", and "Green" *
  *               individual menu text items are modified so that they will  *
  *     contain bands of color. Otherwise, the colors are replaced *
  *     by the text.                                               *
  *                      *
  ****************************************************************************
 void FAR PASCAL HandleChangeColors(hwnd)
 HWND hwnd;
 {
     HMENU hMenu;
     BOOL  fOwnerDraw;

     /* Get a handle to the Colors menu. This is at position 1. */
     hMenu = GetSubMenu (GetMenu (hwnd), IDCOLORS_POS);

     /* Get the current state of the item */
     fOwnerDraw = GetMenuState ( hMenu,
         IDM_COLOROWNERDR, MF_BYCOMMAND) & MF_CHECKED;

     /* Toggle the state of the item. */
     CheckMenuItem ( hMenu,
         IDM_COLOROWNERDR,
         MF_BYCOMMAND | (fOwnerDraw ? MF_UNCHECKED : MF_CHECKED));

     if (!fOwnerDraw){
   /* Change the items to owner-draw items. Pass the RGB value for the
    * color as the application-supplied data. This makes it easier for
    * us to draw the items.
    */
   ModifyMenu(hMenu,
        IDM_BLACK,
        MF_OWNERDRAW | MF_BYCOMMAND,
        IDM_BLACK,
        (LPSTR)RGB (0,0,0));

   ModifyMenu(hMenu,
        IDM_BLUE,
        MF_OWNERDRAW | MF_BYCOMMAND,
        IDM_BLUE,
        (LPSTR)RGB (0,0,255));

   ModifyMenu(hMenu,
        IDM_RED,
        MF_OWNERDRAW | MF_BYCOMMAND,
        IDM_RED,
        (LPSTR)RGB (255,0,0));

   ModifyMenu(hMenu,
        IDM_GREEN,
        MF_OWNERDRAW | MF_BYCOMMAND,
        IDM_GREEN,
        (LPSTR)RGB (0,255,0));
     }
     else {
   /* Change the items to normal text items. */
   ModifyMenu(hMenu, IDM_BLACK, MF_BYCOMMAND, IDM_BLACK, "Black");

   ModifyMenu(hMenu, IDM_BLUE, MF_BYCOMMAND, IDM_BLUE, "Blue");

   ModifyMenu(hMenu, IDM_RED, MF_BYCOMMAND, IDM_RED, "Red");

   ModifyMenu(hMenu, IDM_GREEN, MF_BYCOMMAND, IDM_GREEN, "Green");
     }
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : HandleDrawItem ( hwnd, lpdis)            *
  *                      *
  *  PURPOSE    : Called in response to a WM_DRAWITEM message, i.e. when the *
  *     colors menu is being modified to an owner-draw menu, or    *
  *     one of the items is selected. It sizes the checkmark bitmap*
  *     to fit next to a color band and draws the color bands and  *
  *     the checkmark on the popup menu.          *
  *                      *
  ****************************************************************************
 void FAR PASCAL HandleDrawItem(hwnd, lpdis)
 HWND     hwnd;
 LPDRAWITEMSTRUCT lpdis;

 {
     HDC     hdcBitmap;
     HBITMAP hbmSave;
     HBRUSH  hbr;
     RECT    rc;
     LONG    checkMarkSize;
     DWORD   textColorSave;
     DWORD   bkColorSave;

     /* Get the size of the checkmark so we can leave room for it since we
      * want to be able to check the selected color.
      */
     checkMarkSize = GetMenuCheckMarkDimensions ();

     if (lpdis->itemAction == ODA_SELECT ||
   lpdis->itemAction == ODA_DRAWENTIRE){

   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem);
   InflateRect ((LPRECT)&rc, (-2 - LOWORD(checkMarkSize)), -2);

   if (lpdis->itemState & ODS_SELECTED)
   {
       /* Item has been selected -- hilite with a gray frame */
       hbr = GetStockObject (GRAY_BRUSH);
       FrameRect (lpdis->hDC, (LPRECT)&rc, hbr);
   }
   else if (lpdis->itemAction == ODA_SELECT)
   {
       /* Item has been de-selected -- remove gray frame */
       hbr = CreateSolidBrush (GetSysColor (COLOR_MENU));
       FrameRect (lpdis->hDC, (LPRECT)&rc, hbr);
       DeleteObject (hbr);
   }
     }

     if (lpdis->itemAction == ODA_DRAWENTIRE){

   /* Paint the color item in the color requested. */
   hbr = CreateSolidBrush (lpdis->itemData);
   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem);
   InflateRect ((LPRECT)&rc, -10-LOWORD(checkMarkSize), -10);
   FillRect (lpdis->hDC, (LPRECT)&rc, hbr);
   DeleteObject (hbr);

   if (lpdis->itemState & ODS_CHECKED){
       /* Draw the check mark if the item is checked. */
       hdcBitmap = CreateCompatibleDC (lpdis->hDC);
       hbmSave = SelectObject (hdcBitmap, hbmCheckOn);

       textColorSave = SetTextColor (lpdis->hDC, 0x00000000L);
       bkColorSave   = SetBkColor (lpdis->hDC, 0x00FFFFFFL);

       /* Use Magic bitblt op so that monochrome bitmaps preserve
          background and foreground colors. */
       BitBlt (lpdis->hDC,
         lpdis->rcItem.left,
         lpdis->rcItem.top+
          (MEASUREITEMHEIGHT - HIWORD (checkMarkSize)) / 2,
         LOWORD (checkMarkSize),
         HIWORD (checkMarkSize),
         hdcBitmap,
         0,
         0,
         ROP_PSDPxax);

       /* Restore colors and bitmap and clean up */
       SetTextColor (lpdis->hDC, textColorSave);
       SetBkColor (lpdis->hDC, bkColorSave);
       SelectObject (hdcBitmap, hbmSave);
       DeleteDC (hdcBitmap);

   }
     }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : HandlePopupMenu (hwnd, point)            *
  *                      *
  *  PURPOSE    : Handles the display of the "floating" popup that appears   *
  *     on a mouse click in the app's client area.                 *
  *                      *
  ****************************************************************************
 void FAR PASCAL HandlePopupMenu (hwnd, point)
 HWND   hwnd;
 POINT  point;

 {
     HMENU hMenu;
     HMENU hMenuTrackPopup;

     /* Get the menu for the popup from the resource file. */
     hMenu = LoadMenu (hInst, "PopupMenu");
     if (!hMenu)
   return;

     /* Get the first menu in it which we will use for the call to
      * TrackPopup(). This could also have been created on the fly using
      * CreatePopupMenu and then we could have used InsertMenu() or
      * AppendMenu.
      */
     hMenuTrackPopup = GetSubMenu (hMenu, 0);

     /* Convert the mouse point to screen coordinates since that is what
      * TrackPopup expects.
      */
     ClientToScreen (hwnd, (LPPOINT)&point);

     /* Draw and track the "floating" popup */
     TrackPopupMenu (hMenuTrackPopup, 0, point.x, point.y, 0, hwnd, NULL);

     /* Destroy the menu since were are done with it. */
     DestroyMenu (hMenu);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : MenuWndProc (hWnd, message, wParam, lParam)        *
  *                      *
  *  PURPOSE    : Window function for the main app. window. Processes all the*
  *     menu selections and oter messages.          *
  *                      *
  ****************************************************************************
 long FAR PASCAL MenuWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;

 {
     FARPROC lpProc;
     HMENU hMenu;
     LPDRAWITEMSTRUCT dis;
     RECT rc;


     switch (message){
   case WM_SYSCOMMAND:
       /* Show the About ... dialog */
       if (wParam == ID_ABOUT){
     lpProc = MakeProcInstance (About, hInst);
     DialogBox (hInst,
          "AboutBox",
          hWnd,
          lpProc);

     FreeProcInstance (lpProc);
     break;
       }
       else
         return DefWindowProc (hWnd, message, wParam, lParam);

   case WM_COMMAND:
       switch (wParam){
      case IDM_EXIT:
        DestroyWindow (hWnd);
        break;

      case IDM_ABOUT:
        /* Bring up the About.. dialog box */
        lpProc = MakeProcInstance (About, hInst);
        DialogBox (hInst,
             "AboutBox",
             hWnd,
             lpProc);

        FreeProcInstance (lpProc);
        break;

      case IDM_COLOROWNERDR:
          /* Change colors in color menu depending on state of this
       menu item. */
          HandleChangeColors (hWnd);
          break;

      case IDM_STATE1:
      case IDM_STATE2:
      case IDM_STATE3:
      case IDM_STATE4:
           /* Get a handle to the states menu... */
           hMenu = GetSubMenu (GetMenu (hWnd), IDSTATES_POS);

           /* Uncheck all the items. */
           CheckMenuItem (hMenu, IDM_STATE1,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_STATE2,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_STATE3,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_STATE4,
              MF_BYCOMMAND | MF_UNCHECKED);

           /* ...and just check the selected one.*/
           CheckMenuItem (hMenu, wParam,
              MF_BYCOMMAND | MF_CHECKED);
          break;

      case IDM_BLACK:
      case IDM_RED:
      case IDM_BLUE:
      case IDM_GREEN:
           /* Get a handle to the Colors menu. */
           hMenu = GetSubMenu (GetMenu (hWnd),IDCOLORS_POS);

           /* Uncheck all the items. */
           CheckMenuItem (hMenu, IDM_BLACK,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_RED,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_BLUE,
              MF_BYCOMMAND | MF_UNCHECKED);
           CheckMenuItem (hMenu, IDM_GREEN,
              MF_BYCOMMAND | MF_UNCHECKED);

           /* ...and just check the selected one.*/
           CheckMenuItem (hMenu, wParam,
              MF_BYCOMMAND | MF_CHECKED);
           break;

      case IDM_FONT:
           /* Messages sent to us from TrackPopupMenu when
            * items are selected from the "floating" popups
            */
           MessageBox (hWnd,
           "A font was selected",
           "Popup Menu Alert",
           MB_APPLMODAL|MB_OK);
           break;

      case IDM_SIZE:
           MessageBox (hWnd,
           "A size was selected",
           "Popup Menu Alert",
           MB_APPLMODAL|MB_OK);
           break;

      case IDM_STYLE:
           MessageBox (hWnd,
           "A style was selected",
           "Popup Menu Alert",
           MB_APPLMODAL|MB_OK);
           break;
       }
       break;

   case WM_SIZE:
       if (lParam){
     /* If window is being sized to a non zero value...
      * invalidate it's client area.
      */
     InvalidateRect (hWnd, NULL, TRUE);
       }
       break;

   case WM_PAINT:
       HandlePaint (hWnd);
       break;

   case WM_MEASUREITEM:
       /* Use the same width for all items. We could examine the item id
          and use different widths/heights for each item. */
       ((LPMEASUREITEMSTRUCT)lParam)->itemWidth  = MEASUREITEMWIDTH;
       ((LPMEASUREITEMSTRUCT)lParam)->itemHeight = MEASUREITEMHEIGHT;
       return TRUE;

   case WM_DRAWITEM:
       /* Redraw the "colors" menu in normal/ownerdrawmode */
       HandleDrawItem (hWnd,(LPDRAWITEMSTRUCT)lParam);
       return TRUE;
       break;

   case WM_CREATE:
       /* Create the menu */
       HandleCreate (hWnd);
       break;

   case WM_DESTROY:
       /* Delete the on/off bitmaps so that they don't waste memory. */
       DeleteObject (hbmCheckOn);
       DeleteObject (hbmCheckOff);

       PostQuitMessage (0);
       break;

   case WM_LBUTTONDOWN:
       /* Draw the "floating" popup in the app's client area */
       GetClientRect (hWnd, (LPRECT)&rc);
       if (PtInRect ((LPRECT)&rc, MAKEPOINT (lParam)))
     HandlePopupMenu (hWnd, lParam);
       break;

   default:
       return DefWindowProc(hWnd, message, wParam, lParam);
     }
     return(NULL);
 }


 MPFILE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MPFILE.C

 /***************************************************************************
  *                                                                         *
  *  MODULE    : MpFile.c                                                   *
  *                                                                         *
  *  PURPOSE   : Contains the code for File I/O for Multipad.               *
  *                                                                         *
  *  FUNCTIONS : AlreadyOpen   - Determines if a file is already open.      *
  *                                                                         *
  *              AddFile       - Creates a new MDI window and, if specified,*
  *        loads a file into it.                      *
  *                                                                         *
  *              LoadFile      - Loads a file into a MDI window.            *
  *                                                                         *
  *              ReadFile      - Calls File/Open dialog and appropriately   *
  *                              responds to the user's input.              *
  *                                                                         *
  *              SaveFile      - Saves the contents of a MDI window's edit  *
  *                              control to a file.                         *
  *                                                                         *
  *              SetSaveFrom   - Formats the "Save 'file' to" string.       *
  *                                                                         *
  *              SaveAsDlgProc - Dialog function for the File/SaveAs dialog.*
  *                                                                         *
  *              ChangeFile    - Calls File/SaveAs dialog.                  *
  *                                                                         *
  ***************************************************************************/
 #include "multipad.h"

 VOID NEAR PASCAL GetFileName(PSTR);
 int FAR PASCAL DialogBoxParam(HANDLE,LPSTR,HWND,FARPROC,LONG);

 OFSTRUCT  of;
 /****************************************************************************
  *                                                                          *
  *  FUNCTION   : AlreadyOpen(szFile)                                        *
  *                                                                          *
  *  PURPOSE    : Checks to see if the file described by the string pointed  *
  *               to by 'szFile' is already open.                            *
  *                                                                          *
  *  RETURNS    : a handle to the described file's window if that file is    *
  *               already open;  NULL otherwise.                             *
  *                                                                          *
  ****************************************************************************

 HWND AlreadyOpen(char *szFile)
 {
     int     iDiff;
     HWND    hwndCheck;
     char    szChild[64];
     LPSTR   lpChild, lpFile;
     int     wFileTemp;

     /* Open the file with the OF_PARSE flag to obtain the fully qualified
      * pathname in the OFSTRUCT structure.
      */
     wFileTemp = OpenFile ((LPSTR)szFile, (LPOFSTRUCT)&of, OF_PARSE);
     if (! wFileTemp)
   return(NULL);
     _lclose (wFileTemp);

     /* Check each MDI child window in Multipad */
     for (   hwndCheck = GetWindow(hwndMDIClient, GW_CHILD);
       hwndCheck;
       hwndCheck = GetWindow(hwndCheck, GW_HWNDNEXT)   ) {
   /* Initialization  for comparison */
   lpChild = szChild;
   lpFile = AnsiUpper((LPSTR) of.szPathName);
   iDiff = 0;

   /* Skip icon title windows */
   if (GetWindow(hwndCheck, GW_OWNER))
       continue;

   /* Get current child window's name */
   GetWindowText(hwndCheck, lpChild, 64);

   /* Compare window name with given name */
   while ((*lpChild) && (*lpFile) && (!iDiff)){
       if (*lpChild++ != *lpFile++)
     iDiff = 1;
   }

   /* If the two names matched, the file is already   */
   /* open -- return handle to matching child window. */
   if (!iDiff)
       return(hwndCheck);
     }
     /* No match found -- file is not open -- return NULL handle */
     return(NULL);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : AddFile (lpName)              *
  *                      *
  *  PURPOSE    : Creates a new MDI window. If the lpName parameter is not   *
  *     NULL, it loads a file into the window.         *
  *                      *
  *  RETURNS    : HWND  - A handle to the new window.          *
  *                      *
  ****************************************************************************

 HWND FAR PASCAL AddFile(pName)
 char * pName;
 {
     HWND hwnd;

     char      sz[160];
     MDICREATESTRUCT mcs;

     if (!pName) {
   /* The pName parameter is NULL -- load the "Untitled" string from */
   /* STRINGTABLE and set the title field of the MDI CreateStruct.    */
   LoadString (hInst, IDS_UNTITLED, sz, sizeof(sz));
   mcs.szTitle = (LPSTR)sz;
     }
     else
   /* Title the window with the fully qualified pathname obtained by
    * calling OpenFile() with the OF_PARSE flag (in function
    * AlreadyOpen(), which is called before AddFile().
    */
   mcs.szTitle = of.szPathName;

     mcs.szClass = szChild;
     mcs.hOwner  = hInst;

     /* Use the default size for the window */
     mcs.x = mcs.cx = CW_USEDEFAULT;
     mcs.y = mcs.cy = CW_USEDEFAULT;

     /* Set the style DWORD of the window to default */
     mcs.style = styleDefault;

     /* tell the MDI Client to create the child */
     hwnd = (WORD)SendMessage (hwndMDIClient,
             WM_MDICREATE,
             0,
             (LONG)(LPMDICREATESTRUCT)&mcs);

     /* Did we get a file? Read it into the window */
     if (pName){
   if (!LoadFile(hwnd, pName)){
       /* File couldn't be loaded -- close window */
       SendMessage(hwndMDIClient, WM_MDIDESTROY, (WORD) hwnd, 0L);
   }
     }

     return hwnd;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : LoadFile (lpName)              *
  *                      *
  *  PURPOSE    : Given the handle to a MDI window and a filename, reads the *
  *     file into the window's edit control child.                 *
  *                      *
  *  RETURNS    : TRUE  - If file is sucessfully loaded.         *
  *     FALSE - Otherwise.              *
  *                      *
  ****************************************************************************

 int FAR PASCAL LoadFile (hwnd, pName)
 HWND hwnd;
 char * pName;
 {
     WORD   wLength;
     HANDLE hT;
     LPSTR  lpB;
     HWND   hwndEdit;
     int    fh;

     hwndEdit = GetWindowWord (hwnd, GWW_HWNDEDIT);

     /* The file has a title, so reset the UNTITLED flag. */
     SetWindowWord(hwnd, GWW_UNTITLED, FALSE);

     fh = _lopen (pName, 0);

     /* Make sure file has been opened correctly */
     if ( fh < 0 )
   goto error;

     /* Find the length of the file */
     wLength = (WORD)_llseek (fh, 0L, 2);
     _llseek (fh, 0L, 0);

     /* Attempt to reallocate the edit control's buffer to the file size */
     hT = (HANDLE)SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L);
     if (LocalReAlloc(hT, wLength+1, LHND) == NULL) {
   /* Couldn't reallocate to new size -- error */
   _lclose (fh);
   goto error;
     }

     /* read the file into the buffer */
     if (wLength != _lread (fh, (lpB = (LPSTR)LocalLock (hT)), wLength))
   MPError (hwnd, MB_OK|MB_ICONHAND, IDS_CANTREAD, (LPSTR)pName);

     /* Zero terminate the edit buffer */
     lpB[wLength] = 0;
     LocalUnlock (hT);

     SendMessage (hwndEdit, EM_SETHANDLE, hT, 0L);
     _lclose (fh);

     return TRUE;

 error:
     /* Report the error and quit */
     MPError(hwnd, MB_OK | MB_ICONHAND, IDS_CANTOPEN, (LPSTR)pName);
     return FALSE;
 }

 /****************************************************************************
  *                                                                          *
  *  FUNCTION   : ReadFile(hwnd)                                             *
  *                                                                          *
  *  PURPOSE    : Called in response to a File/Open menu selection. It asks  *
  *               the user for a file name and responds appropriately.       *
  *                                                                          *
  ****************************************************************************

 VOID FAR PASCAL ReadFile(HWND hwnd)
 {
     char    szFile[128];
     HWND    hwndFile;

     GetFileName (szFile);

     /* If the result is not the empty string -- take appropriate action */
     if (*szFile) {
   /* Is file already open?? */
   if (hwndFile = AlreadyOpen(szFile)) {
       /* Yes -- bring the file's window to the top */
       BringWindowToTop(hwndFile);
   }
   else {
       /* No -- make a new window and load file into it */
       AddFile(szFile);
   }
     }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SaveFile (hwnd)              *
  *                      *
  *  PURPOSE    : Saves contents of current edit control to disk.      *
  *                      *
  ****************************************************************************

 VOID FAR PASCAL SaveFile( hwnd )

 HWND hwnd;
 {
     HANDLE   hT;
     LPSTR    lpT;
     char     szFile[128];
     WORD     cch;
     int      fh;
     OFSTRUCT of;
     HWND     hwndEdit;

     PSTR     pch;

     hwndEdit = GetWindowWord ( hwnd, GWW_HWNDEDIT);
     GetWindowText (hwnd, szFile, sizeof(szFile));

     /* If there is no extension (control is 'Untitled') add .TXT as extension
     for (cch = FALSE, lpT = szFile; *lpT; lpT++)
   switch (*lpT){
       case '.':
      cch = TRUE;
      break;

       case '\\':
       case ':' :
      cch = FALSE;
      break;
   }
     if (!cch)
   LoadString (hInst, IDS_ADDEXT, lpT, lpT - (LPSTR)szFile);

     fh = OpenFile (szFile, &of, OF_WRITE | OF_CREATE);

     /* If file could not be opened, quit */
     if (fh < 0){
   MPError (hwnd, MB_OK | MB_ICONHAND, IDS_CANTCREATE, (LPSTR)szFile);
   return;
     }

     /* Find out the length of the text in the edit control */
     cch = GetWindowTextLength (hwndEdit);

     /* Obtain a handle to the text buffer */
     hT  = (HANDLE)SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L);
     lpT = (LPSTR)LocalLock (hT);

     /* Write out the contents of the buffer to the file. */
     if (cch != _lwrite (fh, lpT, cch))
   MPError (hwnd, MB_OK | MB_ICONHAND, IDS_CANTWRITE, (LPSTR)szFile);

     /* Clean up */
     LocalUnlock (hT);
     SendMessage (hwndEdit, EM_SETHANDLE, hT, 0L);

     _lclose (fh);

     return;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SetSaveFrom ()               *
  *                      *
  *  PURPOSE    : Formats the "Save 'file' to .." string.        *
  *                      *
  ****************************************************************************

 VOID NEAR PASCAL SetSaveFrom ( hwnd , psz)
 HWND hwnd;
 PSTR psz;
 {
     char szFmt[32];
     char szText[160];

     /* The text string in the .RC file contains the format string... */
     GetDlgItemText( hwnd, IDD_SAVEFROM, szFmt, sizeof(szFmt));

     /* NOTE: this (LPSTR) cast MUST be here... wsprintf() is a cdecl
      * (C calling conventions) function with varying args... there is
      * no way for the compiler to know that all strings must be LPSTR's
      * and do the conversion, so we have to be careful about wsprintf()'s.
      */
     wsprintf ( szText, szFmt, (LPSTR)psz);

     /* set the text in the static control */
     SetDlgItemText (hwnd, IDD_SAVEFROM, szText);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SaveAsDlgProc(hwnd, message, wParam, lParam)        *
  *                      *
  *  PURPOSE    : Dialog function File/SaveAs. It waits for a filename, and  *
  *     then calls SaveFile or cancels the operation.        *
  *                      *
  ****************************************************************************

 BOOL FAR PASCAL SaveAsDlgProc( hwnd, message, wParam, lParam)
 HWND hwnd;
 WORD message;
 WORD wParam;
 LONG lParam;
 {
     char   sz[64];
     char   *pch;
     BOOL   fExt;
     HWND   hwndSave;

     switch (message){

   case WM_INITDIALOG:

       /* Identify the window whose contents we're saving */
       hwndSave = LOWORD (lParam);

       /* Set it's name in the property list */
       SetProp (hwnd, PROP_FILENAME, hwndSave);

       GetWindowText (hwndSave, sz, sizeof(sz));

       /* Set the save from string... */
       SetSaveFrom (hwnd,sz);

       /* Generate a filename complete with extension */
       AnsiUpper (sz);
       for (fExt = FALSE, pch = sz; *pch; pch++)
     if (*pch == '.')
         fExt = TRUE;
     else if (*pch == '\\')
         fExt = FALSE;
       if (!fExt)
     LoadString (hInst, IDS_ADDEXT, (LPSTR)pch, pch - sz);

       /* Display the filename in the edit control */
       SetDlgItemText (hwnd, IDD_SAVETO, sz);

       /* Select the entire range of text */
       SendDlgItemMessage (hwnd, IDD_SAVETO, EM_SETSEL, 0, MAKELONG (0,100));

       DlgDirList (hwnd, "*.*", IDD_DIRS, IDD_PATH, ATTR_DIRS);

       /* enable OK butto iff edit control is nonempty */
       if (!*sz)
     EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
       break;

   case WM_COMMAND:
       switch (wParam){
     case IDCANCEL:
         /* Abort operation */
         EndDialog(hwnd,1);
         break;

     case IDOK:
        /*  Just change the title of the MDI child. The calling
         *  function of ChangeFile(), which uses the title text
         *  for the filename, will do the actual save.
         */
         hwndSave = GetProp (hwnd, PROP_FILENAME);
         GetDlgItemText (hwnd, IDD_SAVETO, sz, sizeof(sz));
         AnsiUpper ((LPSTR)sz);
         SetWindowText (hwndSave, sz);
         EndDialog (hwnd, 0);
         break;

     case IDD_SAVETO:
        /* If the edit control changes, check to see if its empty.
         * enable OK if it contains something
         */
         if (HIWORD (lParam) != EN_CHANGE)
       return FALSE;
         EnableWindow (GetDlgItem (hwnd, IDOK),
       (WORD) SendDlgItemMessage (hwnd,
                IDD_SAVETO,
                WM_GETTEXTLENGTH,
                0,
                0L));
         break;

     case IDD_DIRS:
         if (HIWORD(lParam)==LBN_DBLCLK){
       char szT[64];

       DlgDirSelect ( hwnd, szT, IDD_DIRS);
       lstrcat ( szT, "*.*");
       DlgDirList (hwnd, szT, IDD_DIRS, IDD_PATH, ATTR_DIRS);
       break;
         }
         return FALSE;

     default:
         return FALSE;
       }

   default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : ChangeFile (hwnd)              *
  *                      *
  *  PURPOSE    : Invokes the File/SaveAs dialog.          *
  *                      *
  *  RETURNS    : TRUE  - if user selected OK or NO.          *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************

 BOOL FAR PASCAL ChangeFile (hwnd)
 HWND hwnd;
 {
     FARPROC lpfn;
     int     i;

     lpfn = MakeProcInstance (SaveAsDlgProc, hInst);
     i = DialogBoxParam (hInst, IDD_SAVEAS, hwnd, lpfn, MAKELONG (hwnd, 0));
     FreeProcInstance (lpfn);
     if (!i)
   SetWindowWord (hwnd, GWW_UNTITLED, 0);
     return !i;
 }


 MPFIND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MPFIND.C

 /***************************************************************************
  *                     *
  *  MODULE  : MpFind.c                   *
  *                     *
  *  PURPOSE  : Code to do text searches in MultiPad.        *
  *                     *
  *  FUNCTIONS  : RealSlowCompare () - Compares subject string with target *
  *               string.           *
  *                     *
  *      FindText ()       - Looks for the search string in the  *
  *               active window.         *
  *                     *
  *      FindPrev ()       - Find previous occurence of search   *
  *               string.           *
  *                     *
  *      FindNext ()       - Find next occurence of search string*
  *                     *
  *      FindDlgProc ()     - Dialog function for Search/Find.    *
  *                     *
  *      Find ()       - Invokes FindDlgProc ()       *
  *                     *
  ***************************************************************************/
 #include "multipad.h"

 #undef HIWORD
 #undef LOWORD

 #define HIWORD(l) (((WORD*)&(l))[1])
 #define LOWORD(l) (((WORD*)&(l))[0])

 BOOL fCase     = FALSE;    /* Turn case sensitivity off */
 char szSearch[160] = "";       /* Initialize search string  */

 /****************************************************************************
  *                      *
  *  FUNCTION   : RealSlowCompare ()              *
  *                      *
  *  PURPOSE    : Compares subject string with the target string. This fn/   *
  *     is called repeatedly so that all substrings are compared,  *
  *     which makes it O(n ** 2), hence it's name.                 *
  *                      *
  *  RETURNS    : TRUE  - If pSubject is identical to pTarget.        *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************

 BOOL NEAR PASCAL RealSlowCompare (pSubject, pTarget )
 register PSTR pSubject;
 register PSTR pTarget;
 {
     if (fCase){
   while (*pTarget)
       if (*pTarget++ != *pSubject++)
     return FALSE;
     }
     else{
   /* If case-insensitive, convert both subject and target to lowercase
    * before comparing.
    */
   AnsiLower ((LPSTR)pTarget);
   while (*pTarget)
       if (*pTarget++ != (char)(DWORD)AnsiLower ((LPSTR)(DWORD)(BYTE)*pSubject
     return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : FindText ()                *
  *                      *
  *  PURPOSE    : Finds the search string in the active window according to  *
  *     search direction (dch) specified ( -1 for reverse and 1 for*
  *     forward searches).              *
  *                      *
  ****************************************************************************
 VOID NEAR PASCAL FindText( dch )
 register int dch;

 {
     register PSTR pText;
     HANDLE    hT;
     LONG    l;
     WORD    cch;
     int     i;

     if (!*szSearch)
   return;

     /* Find the current selection range */
     l = SendMessage(hwndActiveEdit, EM_GETSEL, 0, 0L);

     /* Get the handle to the text buffer and lock it */
     hT    = (HANDLE)SendMessage (hwndActiveEdit, EM_GETHANDLE, 0, 0L);
     pText = LocalLock(hT);

     /* Get the length of the text */
     cch = (WORD)SendMessage (hwndActiveEdit, WM_GETTEXTLENGTH, 0, 0L);

     /* Start with the next char. in selected range ... */
     pText += LOWORD (l) + dch;

     /* Compute how many characters are before/after the current selection*/
     if (dch < 0)
   i = LOWORD (l);
     else
   i = cch - LOWORD (l) + 1 - lstrlen (szSearch);

     /* While there are uncompared substrings... */
     while ( i > 0){
   LOWORD(l)+=dch;

   /* Does this substring match? */
   if (RealSlowCompare(pText,szSearch)){

       /* Yes, unlock the buffer.*/
       LocalUnlock(hT);

       /* Select the located string */
       HIWORD(l) = LOWORD(l) + lstrlen (szSearch);
       SendMessage (hwndActiveEdit, EM_SETSEL, 0, l);
       return;
   }
   i--;

   /* increment/decrement start position by 1 */
   pText += dch;
     }

     /* Not found... unlock buffer. */
     LocalUnlock (hT);

     /* Give a message */
     MPError (hwndFrame, MB_OK | MB_ICONEXCLAMATION, IDS_CANTFIND, (LPSTR)szSe

     return;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : FindPrev ()                *
  *                      *
  *  PURPOSE    : Finds the previous occurence of the search string. Calls   *
  *     FindText () with a negative search direction.        *
  *                      *
  ****************************************************************************
 VOID FAR PASCAL FindPrev(void)
 {
     FindText(-1);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : FindNext ()                *
  *                      *
  *  PURPOSE    : Finds the next occurence of search string. Calls      *
  *     FindText () with a positive search direction.        *
  *                      *
  ****************************************************************************
 VOID FAR PASCAL FindNext(void)
 {
     FindText(1);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : FindDlgProc(hwnd, message, wParam, lParam)        *
  *                      *
  *  PURPOSE    : Dialog function for the Search/Find command. Prompts user  *
  *     for target string, case flag and search direction.      *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL FindDlgProc(hwnd, msg, wParam, lParam)
 HWND hwnd;
 WORD msg;
 WORD wParam;
 LONG lParam;
 {
     switch (msg){
   case WM_INITDIALOG:{

       /* Check/uncheck case button */
       CheckDlgButton (hwnd, IDD_CASE, fCase);

       /* Set default search string to most recently searched string */
       SetDlgItemText (hwnd, IDD_SEARCH, szSearch);

       /* Allow search only if target is nonempty */
       if (!lstrlen (szSearch)){
     EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
     EnableWindow (GetDlgItem (hwnd, IDD_PREV), FALSE);
       }
       break;
   }

   case WM_COMMAND:{

       /* Search forward by default (see IDOK below) */
       int i = 1;

       switch (wParam){
     /* if the search target becomes non-empty, enable searching */
     case IDD_SEARCH:
         if (HIWORD (lParam) == EN_CHANGE){
       if (!(WORD) SendDlgItemMessage (hwnd,
               IDD_SEARCH,
               WM_GETTEXTLENGTH,
               0,
               0L))
           i = FALSE;
       else
           i = TRUE;
       EnableWindow (GetDlgItem (hwnd, IDOK), i);
       EnableWindow (GetDlgItem (hwnd, IDD_PREV), i);
         }
         break;

     case IDD_CASE:
         /* Toggle state of case button */
         CheckDlgButton (hwnd,
             IDD_CASE,
             !IsDlgButtonChecked (hwnd, IDD_CASE));
         break;

     case IDD_PREV:
         /* Set direction to backwards */
         i=-1;
         /*** FALL THRU ***/

     case IDOK:
         /* Save case selection */
         fCase = IsDlgButtonChecked( hwnd, IDD_CASE);

         /* Get search string */
         GetDlgItemText (hwnd, IDD_SEARCH, szSearch, sizeof (szSearch));

         /* Find the text */
         FindText (i);
         /*** FALL THRU ***/

     /* End the dialog */
     case IDCANCEL:
         EndDialog (hwnd, 0);
         break;

     default:
         return FALSE;
       }
       break;
   }
   default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : Find()                 *
  *                      *
  *  PURPOSE    : Invokes the Search/Find dialog.          *
  *                      *
  ****************************************************************************

 VOID FAR PASCAL Find()
 {
     FARPROC lpfn;

     lpfn = MakeProcInstance (FindDlgProc, hInst);
     DialogBox (hInst, IDD_FIND, hwndFrame, lpfn);
     FreeProcInstance (lpfn);
 }


 MPINIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MPINIT.C

 /***************************************************************************
  *                     *
  *  MODULE  : MpInit.c               *
  *                     *
  *  PURPOSE  : Contains initialization code for MultiPad.       *
  *                     *
  *  FUNCTIONS  : InitializeApplication() - Sets up Class data structure   *
  *              and registers window class.    *
  *                     *
  *      InitializeInstance ()   - Does a per-instance initial-   *
  *              ization of MultiPad. Creates   *
  *              the "frame" and MDI client.    *
  *                     *
  ***************************************************************************/
 #include "multipad.h"

 char szFrame[] = "mpframe";   /* Class name for "frame" window */
 char szChild[] = "mpchild";   /* Class name for MDI window     */

 /****************************************************************************
  *                      *
  *  FUNCTION   : InitializeApplication ()            *
  *                      *
  *  PURPOSE    : Sets up the class data structures and does a one-time      *
  *     initialization of the app by registering the window classes*
  *                      *
  *  RETURNS    : TRUE  - If RegisterClass() was successful for both classes.*
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************

 BOOL FAR PASCAL InitializeApplication()
 {
     WNDCLASS  wc;

     /* Register the frame class */
     wc.style       = 0;
     wc.lpfnWndProc   = MPFrameWndProc;
     wc.cbClsExtra    = 0;
     wc.cbWndExtra    = 0;
     wc.hInstance     = hInst;
     wc.hIcon       = LoadIcon(hInst,IDMULTIPAD);
     wc.hCursor       = LoadCursor(NULL,IDC_ARROW);
     wc.hbrBackground = COLOR_APPWORKSPACE+1;
     wc.lpszMenuName  = IDMULTIPAD;
     wc.lpszClassName = szFrame;

     if (!RegisterClass (&wc) )
   return FALSE;

     /* Register the MDI child class */
     wc.lpfnWndProc   = MPMDIChildWndProc;
     wc.hIcon       = LoadIcon(hInst,IDNOTE);
     wc.lpszMenuName  = NULL;
     wc.cbWndExtra    = CBWNDEXTRA;
     wc.lpszClassName = szChild;

     if (!RegisterClass(&wc))
   return FALSE;

     return TRUE;

 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : InitializeInstance ()              *
  *                      *
  *  PURPOSE    : Performs a per-instance initialization of MultiPad. It     *
  *     also creates the frame and an MDI window.        *
  *                      *
  *  RETURNS    : TRUE  - If initialization was successful.        *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL InitializeInstance(LPSTR lpCmdLine, WORD nCmdShow)
 {
     extern HWND  hwndMDIClient;
     char   sz[80], *pCmdLine;
     HDC    hdc;
     HMENU   hmenu;

     /* Get the base window title */
     LoadString (hInst, IDS_APPNAME, sz, sizeof(sz));

     /* Create the frame */
     hwndFrame = CreateWindow (szFrame,
             sz,
             WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
             CW_USEDEFAULT,
             0,
             CW_USEDEFAULT,
             0,
             NULL,
             NULL,
             hInst,
             NULL);

     if ((!hwndFrame) || (!hwndMDIClient))
   return FALSE;

     /* Load main menu accelerators */
     if (!(hAccel = LoadAccelerators (hInst, IDMULTIPAD)))
   return FALSE;

     /* Display the frame window */
     ShowWindow (hwndFrame, nCmdShow);
     UpdateWindow (hwndFrame);

     /* If the command line string is empty, nullify the pointer to it
     ** else copy command line into our data segment
     */
     if ( lpCmdLine && !(*lpCmdLine))
        pCmdLine = NULL;
     else {
         pCmdLine = (char *) LocalAlloc(LPTR, lstrlen(lpCmdLine) + 1);
         if (pCmdLine)
            lstrcpy(pCmdLine, lpCmdLine);
     }

     /* Add the first MDI window */
     AddFile (pCmdLine);

     /* if we allocated a buffer then free it */
     if (pCmdLine)
         LocalFree((LOCALHANDLE) pCmdLine);

     /* Default to minimized windows after the first. */
     styleDefault = 0L;

     return TRUE;

 }


 MPOPEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MPOPEN.C

 /***************************************************************************
  *                     *
  *  MODULE  : MpOpen.c               *
  *                     *
  *  PURPOSE  : Contains the file open dialog function and it's helper   *
  *      functions.               *
  *                     *
  *  FUNCTIONS  : IsWild ()        - Ascertains that the input string   *
  *          contains a DOS wildcard character. *
  *                     *
  *      SelectFile()        - If filename supplied contains a    *
  *          wildcard, this function fills the  *
  *          listboxes in File/Open dialog, else*
  *          the dialog is closed.       *
  *                     *
  *      FileOpenDlgProc()   - Dialog funcion for the File/Open   *
  *          dialog.          *
  *                     *
  *      GetFileName ()      - Gets a file name from the user.    *
  *                     *
  ***************************************************************************/
 #include "multipad.h"

 char szPropertyName [] = "FILENAME";/* Name of the File name property list it

 int FAR PASCAL DialogBoxParam ( HANDLE, LPSTR, HWND, FARPROC, LONG);


 /****************************************************************************
  *                      *
  *  FUNCTION   : IsWild ( psz )               *
  *                      *
  *  PURPOSE    : Checks if the string (referenced by a NEAR pointer)      *
  *     contains a DOS wildcard character ("*" or "?").      *
  *                      *
  *  RETURNS    : TRUE  - iff the string contains a wildcard character.      *
  *     FALSE - otherwise.             .      *
  *                      *
  ****************************************************************************
 BOOL NEAR PASCAL IsWild( psz )
 register PSTR psz;
 {
     for(;;)
   switch (*psz++){
       case '*':
       case '?':
     /* Found wildcard */
     return TRUE;

       case 0:
     /* Reached end of string */
     return FALSE;

       default:
     continue;
   }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : FileExists(pch)                                            *
  *                      *
  *  PURPOSE    : Checks to see if a file exists with the path/filename      *
  *               described by the string pointed to by 'pch'.               *
  *                      *
  *  RETURNS    : TRUE  - if the described file does exist.                  *
  *               FALSE - otherwise.                                         *
  *                      *
  ****************************************************************************

 BOOL FileExists(PSTR pch)
 {
   int fh;

   if ((fh = _lopen((LPSTR) pch, 0)) < 0)
        return(FALSE);

   _lclose(fh);
   return(TRUE);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : SelectFile ( hwnd )              *
  *                      *
  *  PURPOSE    : Reads the string in the edit control of the File/Open      *
  *     dialog. If it contains a wildcard, then it attempts to     *
  *     fill the listboxes in the File/Open dialog. Othewise it    *
  *     ends the dialog. Modifies the FILENAME item in the property*
  *     list of the window.              *
  *                      *
  ****************************************************************************

 VOID NEAR PASCAL SelectFile( hwnd )

 register HWND hwnd;
 {
     register PSTR pch;
     PSTR    pch2;
     int     cch;

     char    szBuf[256];

     /* Get handle (near address) to filename data in window's property list *
     pch = (PSTR)GetProp (hwnd, PROP_FILENAME);

     /* Get the text from the dialog's edit control into this address */
     GetDlgItemText (hwnd, IDD_FILENAME, pch, 64);

     if ( IsWild (pch)){
   /* Select the directory and make a listing of the directories */
   DlgDirList(hwnd, (LPSTR)pch, IDD_DIRS, IDD_PATH, ATTR_DIRS);

   /* Obtain the filename-only part of the path in the edit control */
   for (pch2 = pch; *pch; pch++)
       if (*pch == '\\' || *pch == ':')
     pch2 = pch + 1;

   /* List the files in this directory based on the wildcard. */
   DlgDirList(hwnd, (LPSTR)pch2, IDD_FILES, IDD_PATH, ATTR_FILES);

   /* Set the dialog's edit control to the filename part of path
    * string.
    */
   SetDlgItemText (hwnd, IDD_FILENAME, pch2);
     }
     else
     {
   /* The filename in the property list is not a wildcard */
   if (FileExists (pch)){

       RemoveProp (hwnd, PROP_FILENAME);
       EndDialog (hwnd, 0);
   }
   else{
       MPError ( hwnd, MB_OK | MB_SYSTEMMODAL, IDS_CANTOPEN, (LPSTR) pch);
       SetActiveWindow (hwnd);
   }
     }
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : FileOpenDlgProc()              *
  *                      *
  *  PURPOSE    : Dialog function for the File/Open dialog. Takes care of    *
  *     calling the appropriate functions for extracting the      *
  *     filename and wildcard, filling the listboxes and changing  *
  *     the FILENAME item in the property list for the window.     *
  *                      *
  ****************************************************************************

 BOOL FAR PASCAL FileOpenDlgProc ( hwnd, message, wParam, lParam)
 register HWND hwnd;
 WORD        message;
 register WORD wParam;
 LONG        lParam;
 {
     PSTR pch;

     switch (message){

   case WM_INITDIALOG:
       /* Set the default file extension on edit window, and try to
        * get a listing of the files and directories.
        */
       SetDlgItemText ( hwnd, IDD_FILENAME, DEFFILESEARCH);
       SetProp (hwnd, PROP_FILENAME, LOWORD(lParam));
       SendDlgItemMessage (hwnd, IDD_FILENAME, EM_LIMITTEXT, 64, 0L);
       SelectFile (hwnd);
       break;

   case WM_COMMAND:
       switch (wParam){
     case IDOK:
         SelectFile(hwnd);
         break;

     case IDCANCEL:
         /* Set the filename in the prop. list to NULL and quit */
         pch  = (PSTR) GetProp (hwnd, PROP_FILENAME);
         *pch = 0;
         EndDialog (hwnd, 0);
         break;

     case IDD_FILENAME:
         /* Enable the OK button if the edit control has text. */
         EnableWindow ( GetDlgItem (hwnd, IDOK),
            GetWindowTextLength ((HWND)LOWORD (lParam)));
         break;

     case IDD_FILES:

         /* The files listbox. If file selection has changed, fill
          * the new filename into the property list buffer and set
          * text in edit control.
          */
         if (HIWORD(lParam) == LBN_SELCHANGE){
       pch = (PSTR) GetProp (hwnd, PROP_FILENAME);
       DlgDirSelect (hwnd, (LPSTR)pch, IDD_FILES);
       SetDlgItemText (hwnd, IDD_FILENAME, (LPSTR)pch);
         }
         else if (HIWORD(lParam) == LBN_DBLCLK)
       /* if the item was double-clicked, try to open it */
       SelectFile(hwnd);
         break;

     case IDD_DIRS:

         /* The directories listbox. Append current filename in edit
          * control (stripped of the path prefix) to the name from
          * the property list and set the new string in the edit
          * control.
          */
         if (HIWORD(lParam) == LBN_SELCHANGE){

       PSTR pch2, pchT, pchS;

       pch = (PSTR) GetProp (hwnd, PROP_FILENAME);

       /* Get the new drive/dir */
       DlgDirSelect (hwnd, pch, IDD_DIRS);
       pch2 = pch + lstrlen(pch);

       /* Fetch current contents of dialog's edit control and append
        * it to name from property list... */
       GetDlgItemText(hwnd,IDD_FILENAME,(LPSTR)pch2,64);
       if (*pch2 == 0){
           SetDlgItemText(hwnd, IDD_FILENAME, DEFFILESEARCH);
           GetDlgItemText(hwnd,IDD_FILENAME,(LPSTR)pch2,64);
       }
       else {
           pchS = pch;
           for (pchT = pch = pch2; *pch; pch++) {
         if (*pch == '\\' || *pch == ':')
             pchT = pch2;
         else
             *pchT++ = *pch;
           }
           *pchT = 0;
           pch = pchS;
       }

       /* Set the edit control with new string */
       SetDlgItemText (hwnd, IDD_FILENAME, (LPSTR)pch);
         }
         else if (HIWORD(lParam) == LBN_DBLCLK)
       SelectFile (hwnd);
         break;

     default:
         return FALSE;
       }
       break;

   default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : GetFilename ( pstr )              *
  *                      *
  *  PURPOSE    : Gets a filename from the user by calling the File/Open     *
  *     dialog.                *
  *                      *
  ****************************************************************************
 VOID NEAR PASCAL GetFileName(PSTR pstr)
 {
     FARPROC lpfn;

     lpfn = MakeProcInstance (FileOpenDlgProc, hInst);
     DialogBoxParam (hInst, IDD_FILEOPEN, hwndFrame, lpfn, MAKELONG(pstr,0));
     FreeProcInstance (lpfn);
 }


 MPPRINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MPPRINT.C

 /***************************************************************************
  *                     *
  *  MODULE  : MpPrint()               *
  *                     *
  *  PURPOSE  : Printing code for MultiPad.           *
  *                     *
  *  FUNCTIONS  : GetPrinterDC ()     -  Creates a printer DC for the *
  *                default device.       *
  *                     *
  *      AbortProc ()       -  Export proc. for GDI to check*
  *                print abort.       *
  *                     *
  *      PrintDlgProc ()     -  Dialog function for the print*
  *                cancel dialog.       *
  *                     *
  *      PrintFile ()       -  Prints the contents of the   *
  *                edit control.       *
  *                     *
  *      GetInitializationData () -  Gets DC initialisation data  *
  *                from a DC supporting     *
  *                ExtDeviceMode().       *
  *                     *
  ***************************************************************************/
 #include "multipad.h"

 BOOL fAbort;    /* TRUE if the user has aborted the print job   */
 HWND hwndPDlg;    /* Handle to the cancel print dialog     */
 char szDevice[160];  /* Contains the device, the driver, and the port */
 PSTR szDriver;    /* Pointer to the driver name       */
 PSTR szPort;    /* Port, ie, LPT1         */
 PSTR szTitle;    /* Global pointer to job title       */
 int iPrinter = 0;  /* level of available printer support.     */
       /* 0 - no printer available       */
       /* 1 - printer available       */
       /* 2 - driver supports 3.0 device initialization */
 HANDLE hInitData=NULL;  /* handle to initialization data     */

 char szExtDeviceMode[] = "EXTDEVICEMODE";

 /****************************************************************************
  *                      *
  *  FUNCTION   : GetPrinterDC ()              *
  *                      *
  *  PURPOSE    : Creates a printer display context for the default device.  *
  *     As a side effect, it sets the szDevice and szPort variables*
  *     It also sets iPrinter to the supported level of printing.  *
  *                      *
  *  RETURNS    : HDC   - A handle to printer DC.          *
  *                      *
  ****************************************************************************
 HDC FAR PASCAL GetPrinterDC(void)
 {
     char     szT[32];
     HDC      hdc;
     LPSTR    lpdevmode = NULL;

     iPrinter = 0;

     /* Get the printer information from win.ini into a buffer and
      * null terminate it.
      */
     GetProfileString ( "windows", "device", "" ,szDevice, sizeof(szDevice));
     for (szDriver = szDevice; *szDriver && *szDriver != ','; szDriver++)
   ;
     if (*szDriver)
   *szDriver++ = 0;

     /* From the current position in the buffer, null teminate the
      * list of ports
      */
     for (szPort = szDriver; *szPort && *szPort != ','; szPort++)
   ;
     if (*szPort)
   *szPort++ = 0;

     /* if the device, driver and port buffers all contain meaningful data,
      * proceed.
      */
     if (!*szDevice || !*szDriver || !*szPort){
   *szDevice = 0;
   return NULL;
     }

     /* Create the printer display context */
     if (hInitData){
   /* Get a pointer to the initialization data */
   lpdevmode = (LPSTR) LocalLock (hInitData);

   if (lstrcmp (szDevice, lpdevmode)){
       /* User has changed the device... cancel this setup, as it is
        * invalid (although if we worked harder we could retain some
        * of it).
        */
       lpdevmode = NULL;
       LocalUnlock (hInitData);
       LocalFree (hInitData);
       hInitData = NULL;
   }
     }
     hdc = CreateDC (szDriver, szDevice, szPort, lpdevmode);

     /* Unlock initialization data */
     if (hInitData)
   LocalUnlock (hInitData);

     if (!hdc)
   return NULL;


     iPrinter = 1;

     /* Find out if ExtDeviceMode() is supported and set flag appropriately */
     if (GetProcAddress (GetModuleHandle (szDriver), szExtDeviceMode))
   iPrinter = 2;

     return hdc;

 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : AbortProc()                *
  *                      *
  *  PURPOSE    : To be called by GDI print code to check for user abort.    *
  *                      *
  ****************************************************************************
 int FAR PASCAL AbortProc ( hdc, reserved )
 HDC hdc;
 WORD reserved;
 {
     MSG msg;

     /* Allow other apps to run, or get abort messages */
     while (!fAbort && PeekMessage (&msg, NULL, NULL, NULL, TRUE))
   if (!hwndPDlg || !IsDialogMessage (hwndPDlg, &msg)){
       TranslateMessage (&msg);
       DispatchMessage  (&msg);
   }
     return !fAbort;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : PrintDlgProc ()              *
  *                      *
  *  PURPOSE    : Dialog function for the print cancel dialog box.      *
  *                      *
  *  RETURNS    : TRUE  - OK to abort/ not OK to abort          *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL PrintDlgProc(HWND hwnd, WORD msg, WORD wParam, LONG lParam)
 {
     switch (msg){
   case WM_INITDIALOG:
       /* Set up information in dialog box */
       SetDlgItemText (hwnd, IDD_PRINTDEVICE, (LPSTR)szDevice);
       SetDlgItemText (hwnd, IDD_PRINTPORT, (LPSTR)szPort);
       SetDlgItemText (hwnd, IDD_PRINTTITLE, (LPSTR)szTitle);
       break;

   case WM_COMMAND:
       /* abort printing if the only button gets hit */
       fAbort = TRUE;
       break;

   default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : PrintFile ()                *
  *                      *
  *  PURPOSE    : Prints the contents of the edit control.        *
  *                      *
  ****************************************************************************

 VOID FAR PASCAL PrintFile(HWND hwnd)
 {
     HDC     hdc;
     int     yExtPage;
     char    sz[32];
     WORD    cch;
     WORD    ich;
     PSTR    pch;
     WORD    iLine;
     WORD    nLinesEc;
     WORD    i;
     HANDLE  hT;
     FARPROC lpfnAbort;
     FARPROC lpfnPDlg;
     HWND    hwndPDlg;
     WORD    dy;
     int     yExtSoFar;
     WORD    fError = TRUE;
     HWND    hwndEdit;

     hwndEdit = (HWND)GetWindowWord(hwnd,GWW_HWNDEDIT);

     /* Create the job title by loading the title string from STRINGTABLE */
     cch = LoadString (hInst, IDS_PRINTJOB, sz, sizeof(sz));
     szTitle = sz + cch;
     cch += GetWindowText (hwnd, sz + cch, 32 - cch);
     sz[31] = 0;

     /* Make instances of the Abort proc. and the Print dialog function */
     lpfnAbort = MakeProcInstance (AbortProc, hInst);
     if (!lpfnAbort)
   goto getout;
     lpfnPDlg = MakeProcInstance (PrintDlgProc, hInst);
     if (!lpfnPDlg)
   goto getout4;

     /* Initialize the printer */
     hdc = GetPrinterDC();
     if (!hdc)
   goto getout5;

     /* Disable the main application window and create the Cancel dialog */
     EnableWindow (hwndFrame, FALSE);
     hwndPDlg = CreateDialog (hInst, IDD_PRINT, hwnd, lpfnPDlg);
     if (!hwndPDlg)
   goto getout3;
     ShowWindow (hwndPDlg, SW_SHOW);
     UpdateWindow (hwndPDlg);

     /* Allow the app. to inform GDI of the escape function to call */
     if (Escape (hdc, SETABORTPROC, 0, (LPSTR)lpfnAbort, NULL) < 0)
   goto getout1;

     /* Initialize the document */
     if (Escape (hdc, STARTDOC, cch, (LPSTR)sz, NULL) < 0)
   goto getout1;

     /* Get the height of one line and the height of a page */
     dy = HIWORD (GetTextExtent (hdc, "CC", 2));
     yExtPage = GetDeviceCaps (hdc, VERTRES);

     /* Get the lines in document and and a handle to the text buffer */
     iLine     = 0;
     yExtSoFar = 0;
     nLinesEc  = (WORD)SendMessage (hwndEdit, EM_GETLINECOUNT, 0, 0L);
     hT        = (HANDLE)SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L);

     /* While more lines print out the text */
     while (iLine < nLinesEc){
   if (yExtSoFar + dy > yExtPage){
       /* Reached the end of a page. Tell the device driver to eject a
        * page
        */
       if (Escape (hdc, NEWFRAME, 0, NULL, NULL) < 0 || fAbort)
     goto getout2;
       yExtSoFar = 0;
   }

   /* Get the length and position of the line in the buffer
    * and lock from that offset into the buffer */
   ich = (WORD)SendMessage (hwndEdit, EM_LINEINDEX, iLine, 0L);
   cch = (WORD)SendMessage (hwndEdit, EM_LINELENGTH, ich, 0L);
   pch = LocalLock(hT) + ich;

   /* Print the line and unlock the text handle */
   TextOut (hdc, 0, yExtSoFar, (LPSTR)pch, cch);
   LocalUnlock (hT);

   /* Test and see if the Abort flag has been set. If yes, exit. */
   if (fAbort)
       goto getout2;

   /* Move down the page */
   yExtSoFar += dy;
   iLine++;
     }

     /* Eject the last page. */
     if (Escape (hdc, NEWFRAME, 0, NULL, NULL) < 0)
   goto getout2;

     /* Complete the document. */
     if (Escape (hdc, ENDDOC, 0, NULL, NULL) < 0){
 getout2:
   /* Ran into a problem before NEWFRAME? Abort the document */
   Escape( hdc, ABORTDOC, 0, NULL, NULL);
     }
     else
   fError=FALSE;

 getout3:
     /* Close the cancel dialog and re-enable main app. window */
     EnableWindow (hwndFrame, TRUE);
     DestroyWindow (hwndPDlg);

 getout1:
     DeleteDC(hdc);

 getout5:
     /* Get rid of dialog procedure instances */
     FreeProcInstance (lpfnPDlg);

 getout4:
     FreeProcInstance (lpfnAbort);

 getout:

     /* Error? make sure the user knows... */
     if (fError)
   MPError (hwnd, MB_OK | MB_ICONEXCLAMATION, IDS_PRINTERROR, (LPSTR)szTitle);

     return;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : GetInitializationData()            *
  *                      *
  *  PURPOSE    : Gets DC initialization data from a printer driver      *
  *     supporting ExtDeviceMode(). Called in response to the      *
  *     File/Printer setup menu selection.          *
  *                      *
  *     This function allows the user to change the printer      *
  *     settings FOR MULTIPAD ONLY.  This allows Multipad to print *
  *     in a variety of settings without messing up any other      *
  *     applications. In a more sophisticated application, this    *
  *     setup could even be saved on a document-by-document basis. *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL GetInitializationData( hwnd )
 HWND hwnd ;
 {
     LPSTR     lpOld;
     LPSTR     lpNew;
     FARPROC   lpfn;
     HANDLE    hT,hDrv;
     char      sz[32];
     WORD      cb;
     int       flag;

     /* Pop up dialog for user and retain data in app buffer */
     flag = DM_PROMPT | DM_COPY;

     /* Load the device driver and find the ExtDeviceMode() function */
     wsprintf (sz, "%s.drv", (LPSTR)szDriver);
     if ((hDrv = LoadLibrary (sz)) < 32)
   return FALSE;
     if (!(lpfn = GetProcAddress (hDrv, szExtDeviceMode)))
   return FALSE;

     if (hInitData){
   /* We have some old data... we want to modify the previously specified
    * setup rather than starting with the default setup.
    */
   lpOld = (LPSTR)LocalLock(hInitData);
   flag |= DM_MODIFY;
     }
     else
   lpOld = NULL;

     /* Get the number of bytes needed for the init data */
     cb = (*lpfn) (hwnd,
       hDrv,
       NULL,
       (LPSTR)szDevice,
       (LPSTR)szPort,
       (LPDEVMODE)NULL,
       (LPSTR)NULL,
       0);

     /* Grab some memory for the new data and lock it. */
     hT    = LocalAlloc (LHND,cb);
     lpNew = (LPSTR)LocalLock (hT);

     /* Post the device mode dialog. 0 flag iff user hits OK button */
     if ((*lpfn) (hwnd,
      hDrv,
      (LPDEVMODE)lpNew,
      (LPSTR)szDevice,
      (LPSTR)szPort,
      (LPDEVMODE)lpOld,
      (LPSTR)NULL,
      flag)==IDOK)
   flag = 0;

     /* Unlock the input structures */
     LocalUnlock (hT);
     if (hInitData)
   LocalUnlock (hInitData);

     /* If the user hit OK and everything worked, free the original init.
      * data and retain the new one.  Otherwise, toss the new buffer.
      */
     if (flag)
   LocalFree (hT);
     else{
   if (hInitData)
       LocalFree (hInitData);
   hInitData = hT;
     }

     FreeLibrary(hDrv);
     return (!flag);
 }


 MULTIPAD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MULTIPAD\MULTIPAD.C

 /***************************************************************************
  *                     *
  *  PROGRAM  : MultiPad.c               *
  *                     *
  *  PURPOSE  : To give a multi-Notepad demonstration of the new MDI     *
  *      API in Windows 3.0             *
  *                     *
  *  FUNCTIONS  : WinMain()        - Calls the initialization function  *
  *          and processes message loop     *
  *                     *
  *      MPFrameWndProc()    - Window function for the "frame"    *
  *          window, which controls the menu    *
  *          and contains the MDI document     *
  *          windows as child windows.     *
  *                     *
  *      MPMDIChildWndProc() - Window function for the individual *
  *          document windows       *
  *                     *
  *      InitializeMenu()    - Handles enabling/greying of menu   *
  *          items according to the app's state.*
  *                     *
  *      CloseAllChildren    - Destroys all MDI child windows.    *
  *                     *
  *      CommandHandler()    - Processes the "frame" window's     *
  *          WM_COMMAND messages.       *
  *                     *
  *      AboutDlgProc()      - Dialog function for the ubiquitous *
  *          About.. dialog.        *
  *                     *
  *      SetWrap()        - Alters word wrapping in the edit   *
  *          control.         *
  *                     *
  *      MPError()        - Flashes an error messagebox.     *
  *                     *
  *      QueryCloseChild     - Prompts for saving current MDI     *
  *          child window.         *
  *                     *
  *      QueryCloseAllChildren() - Asks whether it is OK to close *
  *              down app.         *
  *                     *
  ***************************************************************************/

 #include "multipad.h"

 /* global variables used in this module or among more than one module */
 HANDLE hInst;          /* Program instance handle         */
 HANDLE hAccel;          /* Main accelerator resource       */
 HWND hwndFrame     = NULL;    /* Handle to main window         */
 HWND hwndMDIClient   = NULL;    /* Handle to MDI client         */
 HWND hwndActive    = NULL;    /* Handle to currently activated child   */
 HWND hwndActiveEdit   = NULL;    /* Handle to edit control         */
 LONG styleDefault    = WS_MAXIMIZE; /* Default style bits for child windows
             /* The first window is created maximized */
             /* to resemble Notepad.  Later children  */
             /* are normal windows.         */
 LPSTR lpMenu       = IDMULTIPAD;  /* Contains the resource id of the       */
             /* current frame menu         */


 /* Forward declarations of helper functions in this module */
 VOID NEAR PASCAL InitializeMenu (HANDLE);
 VOID NEAR PASCAL CommandHandler (HWND,WORD);
 VOID NEAR PASCAL SetWrap (HWND,BOOL);
 BOOL NEAR PASCAL QueryCloseAllChildren ( VOID );
 int  NEAR PASCAL QueryCloseChild (HWND);

 /****************************************************************************
  *                      *
  *  FUNCTION   : WinMain(HANDLE, HANDLE, LPSTR, int)          *
  *                      *
  *  PURPOSE    : Creates the "frame" window, does some initialization and   *
  *     enters the message loop.            *
  *                      *
  ****************************************************************************
 int NEAR PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
     MSG msg;

     hInst = hInstance;

     /* If this is the first instance of the app. register window classes */
     if (!hPrevInstance){
   if (!InitializeApplication ())
       return 0;
     }

     /* Create the frame and do other initialization */
     if (!InitializeInstance (lpszCmdLine, nCmdShow))
   return 0;

     /* Enter main message loop */
     while (GetMessage (&msg, NULL, 0, 0)){
   /* If a keyboard message is for the MDI , let the MDI client
    * take care of it.  Otherwise, check to see if it's a normal
    * accelerator key (like F3 = find next).  Otherwise, just handle
    * the message as usual.
    */
   if ( !TranslateMDISysAccel (hwndMDIClient, &msg) &&
        !TranslateAccelerator (hwndFrame, hAccel, &msg)){
       TranslateMessage (&msg);
       DispatchMessage (&msg);
   }
     }
     return 0;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : MPFrameWndProc (hwnd, msg, wParam, lParam )        *
  *                      *
  *  PURPOSE    : The window function for the "frame" window, which controls *
  *     the menu and encompasses all the MDI child windows. Does   *
  *     the major part of the message processing. Specifically, in *
  *     response to:                *
  *                      *
  *         WM_CREATE    : Creates and displays the "frame". *
  *                      *
  *         WM_INITMENU  : Sets up the state of the menu.    *
  *                      *
  *         WM_WININICHANGE &  : If default printer characteristics*
  *         WM_DEVMODECHANGE    have been changed, reinitialises  *
  *            printer DC.          *
  *                      *
  *         WM_COMMAND   : Passes control to a command-      *
  *            handling function.        *
  *                      *
  *         WM_CLOSE    : Quits the app. if all the child   *
  *            windows agree.        *
  *                      *
  *         WM_QUERYENDSESSION : Checks that all child windows     *
  *            agree to quit.        *
  *                      *
  *         WM_DESTROY   : Destroys frame window and quits   *
  *            app.            *
  *                      *
  ****************************************************************************
 LONG FAR PASCAL MPFrameWndProc ( hwnd, msg, wParam, lParam )

 register HWND   hwnd;
 WORD     msg;
 register WORD   wParam;
 LONG     lParam;

 {
     switch (msg){
   case WM_CREATE:{

       CLIENTCREATESTRUCT ccs;
       HDC hdc;

       /* Find window menu where children will be listed */
       ccs.hWindowMenu = GetSubMenu (GetMenu(hwnd),WINDOWMENU);
       ccs.idFirstChild = IDM_WINDOWCHILD;

       /* Create the MDI client filling the client area */
       hwndMDIClient = CreateWindow ("mdiclient",
             NULL,
             WS_CHILD | WS_CLIPCHILDREN |
             WS_VSCROLL | WS_HSCROLL,
             0,
             0,
             0,
             0,
             hwnd,
             0xCAC,
             hInst,
             (LPSTR)&ccs);


       ShowWindow (hwndMDIClient,SW_SHOW);

       /* Check if printer can be initialized */
       if (hdc = GetPrinterDC ()){
     DeleteDC (hdc);
       }

       break;
   }

   case WM_INITMENU:
       /* Set up the menu state */
       InitializeMenu ((HMENU)wParam);
       break;

   case WM_WININICHANGE:
   case WM_DEVMODECHANGE:{

       /*  If control panel changes default printer characteristics,
        *  reinitialize our printer information...
        */
       HDC hdc;

       if (hdc = GetPrinterDC ()){
     DeleteDC (hdc);
       }
       break;
   }


   case WM_COMMAND:
       /* Direct all menu selection or accelerator commands to another
        * function
        */
       CommandHandler (hwnd,wParam);
       break;

   case WM_CLOSE:
       /* don't close if any children cancel the operation */
       if (!QueryCloseAllChildren ())
     break;
       DestroyWindow (hwnd);
       break;

   case WM_QUERYENDSESSION:
       /*  Before session ends, check that all files are saved */
       return QueryCloseAllChildren ();

   case WM_DESTROY:
       PostQuitMessage (0);
       break;

   default:
       /*  use DefFrameProc() instead of DefWindowProc() since there
        *  are things that have to be handled differently because of MDI
        */
       return DefFrameProc (hwnd,hwndMDIClient,msg,wParam,lParam);
     }
     return 0;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : MPMDIWndProc ( hwnd, msg, wParam, lParam )        *
  *                      *
  *  PURPOSE    : The window function for the individual document windows,   *
  *     each of which has a "note". Each of these windows contain  *
  *     one multi-line edit control filling their client area.     *
  *     In response to the following:            *
  *                      *
  *         WM_CREATE    : Creates & diplays an edit control *
  *            and does some initialization.     *
  *                      *
  *         WM_MDIACTIVATE  : Activates/deactivates the child.  *
  *                      *
  *         WM_SETFOCUS  : Sets focus on the edit control.   *
  *                      *
  *         WM_SIZE    : Resizes the edit control.      *
  *                      *
  *         WM_COMMAND   : Processes some of the edit      *
  *            commands, saves files and alters  *
  *            the edit wrap state.        *
  *                      *
  *         WM_CLOSE    : Closes child if it is ok to do so.*
  *                      *
  *         WM_QUERYENDSESSION : Same as above.        *
  *                      *
  ****************************************************************************

 LONG FAR PASCAL MPMDIChildWndProc ( hwnd, msg, wParam, lParam )

 register HWND  hwnd;
 WORD    msg;
 register WORD  wParam;
 LONG    lParam;

 {
     HWND hwndEdit;

     switch (msg){
   case WM_CREATE:
       /* Create an edit control */
       hwndEdit = CreateWindow ("edit",
              NULL,
              WS_CHILD|WS_HSCROLL|WS_MAXIMIZE|WS_VISIBLE|WS_VSCROLL|ES_AUTOHSC
              0,
              0,
              0,
              0,
              hwnd,
              ID_EDIT,
              hInst,
              NULL);

       /* Remember the window handle and initialize some window attributes */
       SetWindowWord (hwnd, GWW_HWNDEDIT, (WORD)hwndEdit);
       SetWindowWord (hwnd, GWW_CHANGED, FALSE);
       SetWindowWord (hwnd, GWW_WORDWRAP, FALSE);
       SetWindowWord (hwnd, GWW_UNTITLED, TRUE);
       SetFocus (hwndEdit);
       break;

   case WM_MDIACTIVATE:
       /* If we're activating this child, remember it */
       if (wParam){
     hwndActive     = hwnd;
     hwndActiveEdit = (HWND)GetWindowWord (hwnd, GWW_HWNDEDIT);
       }
       else{
     hwndActive     = NULL;
     hwndActiveEdit = NULL;
       }
       break;

   case WM_QUERYENDSESSION:
       /* Prompt to save the child */
       return !QueryCloseChild (hwnd);

   case WM_CLOSE:
       /* If its OK to close the child, do so, else ignore */
       if (QueryCloseChild (hwnd))
     goto CallDCP;
       else
     break;

   case WM_SIZE:{
       RECT rc;

       /* On creation or resize, size the edit control. */
       hwndEdit = GetWindowWord (hwnd, GWW_HWNDEDIT);
       GetClientRect (hwnd, &rc);
       MoveWindow (hwndEdit,
       rc.left,
       rc.top,
       rc.right-rc.left,
       rc.bottom-rc.top,
       TRUE);
       goto CallDCP;
   }

   case WM_SETFOCUS:
       SetFocus (GetWindowWord (hwnd, GWW_HWNDEDIT));
       break;

   case WM_COMMAND:
       switch (wParam){
     case ID_EDIT:
         switch (HIWORD(lParam)){
       case EN_CHANGE:

           /* If the contents of the edit control have changed,
              set the changed flag
            */
           SetWindowWord (hwnd, GWW_CHANGED, TRUE);
           break;

       case EN_ERRSPACE:
           /* If the control is out of space, honk */
           MessageBeep (0);
           break;

       default:
           goto CallDCP;
         }
         break;

     case IDM_FILESAVE:
         /* If empty file, ignore save */
         if ((GetWindowWord(hwnd, GWW_UNTITLED)) && (!ChangeFile(hwnd)))
       break;

         /* Save the contents of the edit control and reset the
          * changed flag
          */
         SaveFile (hwnd);
         SetWindowWord (hwnd, GWW_CHANGED, FALSE);
         break;

     case IDM_EDITWRAP: {
         int fWrap = GetWindowWord (hwnd, GWW_WORDWRAP);

         /* Set the wrap state, or report it */
         if (LOWORD (lParam)){
       fWrap = !fWrap;
       SetWrap (hwnd, fWrap);
         }

         /* return wrap state */
         return fWrap;
     }

     default:
         goto CallDCP;
       }
       break;

   default:
 CallDCP:
       /* Again, since the MDI default behaviour is a little different,
        * call DefMDIChildProc instead of DefWindowProc()
        */
       return DefMDIChildProc (hwnd, msg, wParam, lParam);
     }
     return FALSE;
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : AboutDlgProc ( hwnd, msg, wParam, lParam )        *
  *                      *
  *  PURPOSE    : Dialog function for the About MultiPad... dialog.      *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL AboutDlgProc ( hwnd, msg, wParam, lParam )
 HWND        hwnd;
 register WORD msg;
 register WORD wParam;
 LONG        lParam;
 {
     switch (msg){
   case WM_INITDIALOG:
       /* nothing to initialize */
       break;

   case WM_COMMAND:
       switch (wParam){
     case IDOK:
     case IDCANCEL:
         EndDialog(hwnd, 0);
         break;

     default:
         return FALSE;
       }
       break;

   default:
       return FALSE;
     }

     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : Initializemenu ( hMenu )            *
  *                      *
  *  PURPOSE    : Sets up greying, enabling and checking of main menu items  *
  *     based on the app's state.                                  *
  *                      *
  ****************************************************************************
 VOID NEAR PASCAL InitializeMenu ( hmenu )
 register HANDLE hmenu;
 {
     register WORD status;
     int     i;
     int     j;
     long    l;

     /* Is there any active child to talk to? */
     if (hwndActiveEdit){
   /* If edit control can respond to an undo request, enable the
    * undo selection.
    */
   if (SendMessage (hwndActiveEdit, EM_CANUNDO, 0, 0L))
       status = MF_ENABLED;
   else
       status = MF_GRAYED;
   EnableMenuItem (hmenu, IDM_EDITUNDO, status);

   /* If edit control is non-empty, allow cut/copy/clear */
   l      = SendMessage (hwndActiveEdit, EM_GETSEL, 0, 0L);
   status = (HIWORD(l) == LOWORD(l)) ? MF_GRAYED : MF_ENABLED;
   EnableMenuItem (hmenu, IDM_EDITCUT, status);
   EnableMenuItem (hmenu, IDM_EDITCOPY, status);
   EnableMenuItem (hmenu, IDM_EDITCLEAR, status);

   status=MF_GRAYED;
   /* If the clipboard contains some CF_TEXT data, allow paste */
   if (OpenClipboard (hwndFrame)){
       int wFmt = 0;

       while (wFmt = EnumClipboardFormats (wFmt))
     if (wFmt == CF_TEXT){
         status = MF_ENABLED;
         break;
     }

       CloseClipboard ();
   }
   EnableMenuItem (hmenu, IDM_EDITPASTE, status);

   /* Set the word wrap state for the window */
   if ((WORD) SendMessage (hwndActive, WM_COMMAND, IDM_EDITWRAP, 0L))
       status = MF_CHECKED;
   else
       status = MF_UNCHECKED;
   CheckMenuItem (hmenu, IDM_EDITWRAP, status);

   /* Enable search menu items only if there is a search string */
   if (*szSearch)
       status = MF_ENABLED;
   else
       status = MF_GRAYED;
   EnableMenuItem (hmenu, IDM_SEARCHNEXT, status);
   EnableMenuItem (hmenu, IDM_SEARCHPREV, status);

   /* Enable File/Print only if a printer is available */
   status = iPrinter ? MF_ENABLED : MF_GRAYED;
   EnableMenuItem (hmenu, IDM_FILEPRINT, status);

   /* select all and wrap toggle always enabled */
   status = MF_ENABLED;
   EnableMenuItem(hmenu, IDM_EDITSELECT, status);
   EnableMenuItem(hmenu, IDM_EDITWRAP, status);
   EnableMenuItem(hmenu, IDM_SEARCHFIND, status);
     }
     else {
   /* There are no active child windows */
   status = MF_GRAYED;

   /* No active window, so disable everything */
   for (i = IDM_EDITFIRST; i <= IDM_EDITLAST; i++)
       EnableMenuItem (hmenu, i, status);

   CheckMenuItem (hmenu, IDM_EDITWRAP, MF_UNCHECKED);

   for (i = IDM_SEARCHFIRST; i <= IDM_SEARCHLAST; i++)
       EnableMenuItem (hmenu, i, status);

   EnableMenuItem (hmenu, IDM_FILEPRINT, status);

     }

     /* The following menu items are enabled if there is an active window */
     EnableMenuItem (hmenu, IDM_FILESAVE, status);
     EnableMenuItem (hmenu, IDM_FILESAVEAS, status);
     EnableMenuItem (hmenu, IDM_WINDOWTILE, status);
     EnableMenuItem (hmenu, IDM_WINDOWCASCADE, status);
     EnableMenuItem (hmenu, IDM_WINDOWICONS, status);
     EnableMenuItem (hmenu, IDM_WINDOWCLOSEALL, status);

     /* Allow printer setup only if printer driver supports device initializat
     if (iPrinter < 2)
   status = MF_GRAYED;
     EnableMenuItem ( hmenu, IDM_FILESETUP, status);

 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : CloseAllChildren ()              *
  *                      *
  *  PURPOSE    : Destroys all MDI child windows.          *
  *                      *
  ****************************************************************************
 VOID NEAR PASCAL CloseAllChildren ()
 {
     register HWND hwndT;

     /* hide the MDI client window to avoid multiple repaints */
     ShowWindow(hwndMDIClient,SW_HIDE);

     /* As long as the MDI client has a child, destroy it */
     while ( hwndT = GetWindow (hwndMDIClient, GW_CHILD)){

   /* Skip the icon title windows */
   while (hwndT && GetWindow (hwndT, GW_OWNER))
       hwndT = GetWindow (hwndT, GW_HWNDNEXT);

   if (!hwndT)
       break;

   SendMessage (hwndMDIClient, WM_MDIDESTROY, (WORD)hwndT, 0L);
     }
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : CommandHandler ()              *
  *                      *
  *  PURPOSE    : Processes all "frame" WM_COMMAND messages.        *
  *                      *
  ****************************************************************************
 VOID NEAR PASCAL CommandHandler ( hwnd, wParam )
 register HWND hwnd;
 register WORD wParam;

 {
     switch (wParam){
   case IDM_FILENEW:
       /* Add a new, empty MDI child */
       AddFile (NULL);
       break;

   case IDM_FILEOPEN:
       ReadFile (hwnd);
       break;

   case IDM_FILESAVE:
       /* Save the active child MDI */
       SendMessage (hwndActive, WM_COMMAND, IDM_FILESAVE, 0L);
       break;

   case IDM_FILESAVEAS:
       /* Save active child MDI under another name */
       if (ChangeFile (hwndActive))
     SendMessage (hwndActive, WM_COMMAND, IDM_FILESAVE, 0L);
       break;

   case IDM_FILEPRINT:
       /* Print the active child MDI */
       PrintFile (hwndActive);
       break;

   case IDM_FILESETUP:
       /* Set up the printer environment for this app */
       GetInitializationData (hwnd);
       break;

   case IDM_FILEMENU:{

         /* lengthen / shorten the size of the MDI menu */
         HMENU hMenu;
         HMENU hWindowMenu;
         int i;

         if (lpMenu == IDMULTIPAD){
       lpMenu = IDMULTIPAD2;
       i   = SHORTMENU;
         }
         else{
       lpMenu = IDMULTIPAD;
       i   = WINDOWMENU;
         }

         hMenu = LoadMenu (hInst, lpMenu);
         hWindowMenu = GetSubMenu (hMenu, i);

         /* Set the new menu */
         hMenu = (HMENU)SendMessage (hwndMDIClient,
             WM_MDISETMENU,
             0,
             MAKELONG(hMenu,hWindowMenu));

         DestroyMenu (hMenu);
         DrawMenuBar (hwndFrame);
         break;
   }

   case IDM_FILEEXIT:
       /* Close Multipad */
       SendMessage (hwnd, WM_CLOSE, 0, 0L);
       break;

   case IDM_HELPABOUT:{
       /* Bring up the ubiquitous Ego box */
       FARPROC lpfn;

       lpfn = MakeProcInstance(AboutDlgProc, hInst);
       DialogBox (hInst, IDD_ABOUT, hwnd, lpfn);
       FreeProcInstance (lpfn);
       break;
   }

   /* The following are edit commands. Pass these off to the active
    * child's edit control window.
    */
   case IDM_EDITCOPY:
       SendMessage (hwndActiveEdit, WM_COPY, 0, 0L);
       break;

   case IDM_EDITPASTE:
       SendMessage (hwndActiveEdit, WM_PASTE, 0, 0L);
       break;

   case IDM_EDITCUT:
       SendMessage (hwndActiveEdit, WM_CUT, 0, 0L);
       break;

   case IDM_EDITCLEAR:
       SendMessage (hwndActiveEdit, EM_REPLACESEL, 0,( LONG)(LPSTR)"");
       break;

   case IDM_EDITSELECT:
       SendMessage (hwndActiveEdit, EM_SETSEL, 0, MAKELONG(0, 0xe000));
       break;

   case IDM_EDITUNDO:
       SendMessage (hwndActiveEdit, EM_UNDO, 0, 0L);
       break;

   case IDM_EDITWRAP:
       SendMessage (hwndActive, WM_COMMAND, IDM_EDITWRAP, 1L);
       break;

   case IDM_SEARCHFIND:
       /* Put up the find dialog box */
       Find ();
       break;

   case IDM_SEARCHNEXT:
       /* Find next occurence */
       FindNext ();
       break;

   case IDM_SEARCHPREV:
       /* Find previous occurence */
       FindPrev ();
       break;

   /* The following are window commands - these are handled by the
    * MDI Client.
    */
   case IDM_WINDOWTILE:
       /* Tile MDI windows */
       SendMessage (hwndMDIClient, WM_MDITILE, 0, 0L);
       break;

   case IDM_WINDOWCASCADE:
       /* Cascade MDI windows */
       SendMessage (hwndMDIClient, WM_MDICASCADE, 0, 0L);
       break;

   case IDM_WINDOWICONS:
       /* Auto - arrange MDI icons */
       SendMessage (hwndMDIClient, WM_MDIICONARRANGE, 0, 0L);
       break;

   case IDM_WINDOWCLOSEALL:
       /* Abort operation if something is not saved */
       if (!QueryCloseAllChildren())
     break;

       CloseAllChildren();

       /* Show the window since CloseAllChilren() hides the window
        * for fewer repaints.
        */
       ShowWindow( hwndMDIClient, SW_SHOW);

       break;

   default:
      /*
       * This is essential, since there are frame WM_COMMANDS generated
       * by the MDI system for activating child windows via the
       * window menu.
       */
       DefFrameProc(hwnd, hwndMDIClient, WM_COMMAND, wParam, 0L);
     }
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : SetWrap ()                *
  *                      *
  *  PURPOSE    : Changes the word wrapping in an edit control. Since this   *
  *     cannot be done by direct means, the function creates a new *
  *     edit control, moves data from the old control to the new   *
  *     control and destroys the original control. Note that the   *
  *     function assumes that the child being modified is currently*
  *     active.                *      *
  *                      *
  ****************************************************************************

 VOID NEAR PASCAL SetWrap(hwnd, fWrap)
 HWND hwnd;
 BOOL fWrap;

 {
     LONG    dws;
     HANDLE  hT;
     HANDLE  hTT;
     HWND    hwndOld;
     HWND    hwndNew;
     RECT    rc;

     /* Change word wrap mode */
     SetWindowWord (hwnd, GWW_WORDWRAP, fWrap);

     /* Create the appropriate window style, adding a horizontal scroll
      * facility if wrapping is not present.
      */
     dws = WS_CHILD | WS_VSCROLL | ES_AUTOVSCROLL | ES_MULTILINE;
     if (!fWrap)
   dws |= WS_HSCROLL | ES_AUTOHSCROLL;

     /* Create a new child window */
     hwndNew = CreateWindow ( "edit",
            NULL,
            dws,
            0,
            SW_SHOW,
            0,
            0,
            hwnd,
            ID_EDIT,
            hInst,
            NULL);

     /* Get handle to current edit control */
     hwndOld = GetWindowWord (hwnd, GWW_HWNDEDIT);

     /* Get the data handle of the old control */
     hT = (HANDLE)SendMessage (hwndOld, EM_GETHANDLE, 0, 0L);

     /* Create a dummy data handle and make it the handle to
      * the old edit control( hT still references the text of
      * old control).
      */
     hTT = LocalAlloc (LHND, 0);
     SendMessage (hwndOld, EM_SETHANDLE, hTT, 0L);

     /* Make the new window the window of interest and destroy the
      * old control.
      */
     SetWindowWord (hwnd, GWW_HWNDEDIT, hwndNew);
     hwndActiveEdit = hwndNew;
     DestroyWindow (hwndOld);

     /* Cause the window to be properly sized */
     SendMessage (hwnd, WM_SIZE, 0, 0L);

     /* Free the new window's old data handle and set it to
      * hT (text of old edit control)
      */
     LocalFree ((HANDLE)SendMessage (hwndNew, EM_GETHANDLE, 0, 0L));
     SendMessage (hwndNew, EM_SETHANDLE, hT, 0L);

     ShowWindow (hwndNew, SW_SHOW);

     /* Set focus to the new edit control */
     SetFocus (hwndNew);

 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : MPError ( hwnd, flags, id, ...)          *
  *                      *
  *  PURPOSE    : Flashes a Message Box to the user. The format string is    *
  *     taken from the STRINGTABLE.            *
  *                      *
  *  RETURNS    : Returns value returned by MessageBox() to the caller.      *
  *                      *
  ****************************************************************************
 short FAR CDECL MPError(hwnd, bFlags, id, ...)
 HWND hwnd;
 WORD bFlags;
 WORD id;
 {
     char sz[160];
     char szFmt[128];

     LoadString (hInst, id, szFmt, sizeof (szFmt));
     wvsprintf (sz, szFmt, (LPSTR)(&id + 1));
     LoadString (hInst, IDS_APPNAME, szFmt, sizeof (szFmt));
     return MessageBox (hwndFrame, sz, szFmt, bFlags);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : QueryCloseAllChildren()            *
  *                      *
  *  PURPOSE    : Asks the child windows if it is ok to close up app. Nothing*
  *     is destroyed at this point. The z-order is not changed.    *
  *                      *
  *  RETURNS    : TRUE - If all children agree to the query.        *
  *     FALSE- If any one of them disagrees.          *
  *                      *
  ****************************************************************************

 BOOL NEAR PASCAL QueryCloseAllChildren()
 {
     register HWND hwndT;

     for ( hwndT = GetWindow (hwndMDIClient, GW_CHILD);
     hwndT;
     hwndT = GetWindow (hwndT, GW_HWNDNEXT)       ){

   /* Skip if an icon title window */
   if (GetWindow (hwndT, GW_OWNER))
       continue;

   if (SendMessage (hwndT, WM_QUERYENDSESSION, 0, 0L))
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : QueryCloseChild (hwnd)             *
  *                      *
  *  PURPOSE    : If the child MDI is unsaved, allow the user to save, not   *
  *               save, or cancel the close operation.                       *
  *                      *
  *  RETURNS    : TRUE  - if user chooses save or not save, or if the file   *
  *                       has not changed.                                   *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************

 BOOL NEAR PASCAL QueryCloseChild(hwnd)
 register HWND hwnd;
 {
     char   sz [64];
     register int i;

     /* Return OK if edit control has not changed. */
     if (!GetWindowWord (hwnd, GWW_CHANGED))
   return TRUE;

     GetWindowText (hwnd, sz, sizeof(sz));

     /* Ask user whether to save / not save / cancel */
     i = MPError (hwnd,
      MB_YESNOCANCEL|MB_ICONQUESTION,IDS_CLOSESAVE,
      (LPSTR)sz);

     switch (i){
   case IDYES:
       /* User wants file saved */
       SaveFile(hwnd);
       break;

   case IDNO:
       /* User doesn't want file saved */
       break;

   default:
       /* We couldn't do the messagebox, or not ok to close */
       return FALSE;
     }
     return TRUE;
 }


 MYPAL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\MYPAL\MYPAL.C

 /***************************************************************************
  *                     *
  *  PROGRAM  : MyPal.c               *
  *                     *
  *  PURPOSE  : Sets up a bar representation of the current physical     *
  *      palette and displays useful information regarding     *
  *      pixel colors and palette indices.         *
  *                     *
  *  FUNCTIONS  : WinMain() - calls initialization function,       *
  *            processes message loop         *
  *                     *
  *      WndProc() - Window function for app. Processes     *
  *            window messages.           *
  *                     *
  *    ShowColor() - Displays a little box on each side of the    *
  *            caption bar displaying the pixel color at the*
  *            mouse position.           *
  ***************************************************************************/

 #include <windows.h>
 #include "mypal.h"

 HANDLE    hPal;         /* Handle to the application's logical palette */
 static WORD  nSizeX;        /* Width of the application window        */
 static WORD  nSizeY;        /* Height of the application window        */
 NPLOGPALETTE  pLogPal;       /* Pointer to program's logical palette        *
 WORD    nXBorder;      /* Width of window border          */
 WORD    nXTitle;       /* Width of title bar            */
 WORD    nYTitle;       /* Height of title bar            */
 BOOL    bCaptureOn;    /* Indicates if mouse capture is on        */
 int    iIndex;        /* Last index selected in palette        */
 char    szTitlebuf[90];/* Buffer for pixel and palette info. text     */
 HDC    hDCGlobal;     /* The Screen DC             */
 int    iNumColors;    /* Number of colors supported by device        */
 int    iRasterCaps;   /* Raster capabilities            */
 int    iPalSize;      /* Size of Physical palette          */
 RECT    rClientRect;   /* Client rectangle coordinates          */
 DWORD   dwPal[PALETTESIZE];   /* Stores palette entries for later lookup
 int    iGlobalXOffset;
 int    iGlobalYOffset;
 int    iYMiddle;

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 /****************************************************************************
  *                      *
  *  FUNCTION   : void ShowColor(HWND hWnd, HDC hDC)          *
  *                      *
  *  PURPOSE    : Displays a little box on each side of the caption bar      *
  *     displaying the pixel color at the mouse position.      *
  *                      *
  ****************************************************************************
 void ShowColor (hWnd, hDC)
 HWND  hWnd;
 HDC   hDC;
 {
      HBRUSH  hBrush, hOldBrush;

      hBrush    = CreateSolidBrush ( PALETTEINDEX(iIndex) );
      hOldBrush = SelectObject (hDC,hBrush) ;

      GetWindowRect (hWnd, (LPRECT)&rClientRect);

      PatBlt ( hDC,
         rClientRect.left + nXTitle + nXBorder + 1,
         rClientRect.top + nXBorder,
         nXTitle,
         nYTitle,
         PATCOPY);

      PatBlt(hDC,
       rClientRect.right - ( 3 * nXTitle + nXBorder + 2),
       rClientRect.top + nXBorder,
       nXTitle,
       nYTitle,
       PATCOPY);
      SelectObject (hDC, hOldBrush);
      DeleteObject (hBrush) ;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : WinMain(HANDLE, HANDLE, LPSTR, int)          *
  *                      *
  *  PURPOSE    : Creates the app. window and processes the message loop.    *
  *                      *
  ****************************************************************************
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;

 {
      static char szAppName [] = "MyPal";
      HWND   hWnd;
      WNDCLASS   wndclass;
      MSG   msg ;
      short int   xScreen;
      short int   yScreen;

      if (!hPrevInstance){
    wndclass.style   = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc  = WndProc;
    wndclass.cbClsExtra  = 0;
    wndclass.cbWndExtra  = 0;
    wndclass.hInstance  = hInstance;
    wndclass.hIcon   = LoadIcon(hInstance, szAppName);
    wndclass.hCursor  = LoadCursor (NULL, IDC_ARROW);
    wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
    wndclass.lpszMenuName  = szAppName;
    wndclass.lpszClassName = szAppName;

    if (!RegisterClass (&wndclass))
        return FALSE ;
      }

      /* Do some global initializations */
      xScreen   = GetSystemMetrics (SM_CXSCREEN);
      yScreen   = GetSystemMetrics (SM_CYSCREEN);
      nXBorder   = GetSystemMetrics (SM_CXFRAME);
      nXTitle   = GetSystemMetrics (SM_CXSIZE);
      nYTitle   = GetSystemMetrics (SM_CYSIZE);
      iIndex   = 0;
      bCaptureOn  = FALSE;

      hDCGlobal   = GetDC (NULL);
      iPalSize   = GetDeviceCaps (hDCGlobal, SIZEPALETTE);
      iRasterCaps = GetDeviceCaps (hDCGlobal, RASTERCAPS);
      iRasterCaps = (iRasterCaps & RC_PALETTE) ? TRUE : FALSE;
      ReleaseDC (NULL,hDCGlobal);

      if (iRasterCaps)
    iNumColors = GetDeviceCaps(hDCGlobal, SIZEPALETTE);
      else
    iNumColors = GetDeviceCaps( hDCGlobal, NUMCOLORS);

      nSizeX = ((xScreen - 2*nXBorder) / PALETTESIZE) * PALETTESIZE;

      /* create the app. window */
      hWnd = CreateWindow (szAppName,
         "My Physical Palette ",
         WS_OVERLAPPEDWINDOW,
         (xScreen-nSizeX) / 2 - nXBorder,
         yScreen - ( 4 * GetSystemMetrics (SM_CYCAPTION)),
         nSizeX + 2 * nXBorder,
         4 * GetSystemMetrics (SM_CYCAPTION),
         NULL,
         NULL,
         hInstance,
         NULL);
      ShowWindow (hWnd, nCmdShow);
      UpdateWindow (hWnd);

      while (GetMessage (&msg, NULL, 0, 0)){
      TranslateMessage (&msg) ;
      DispatchMessage (&msg) ;
      }

      return msg.wParam ;
 }

 /****************************************************************************
  *                        *
  *  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)            *
  *                        *
  *  PURPOSE:  Processes window messages and sets up a 256 bar representation
  *        of the current physical palette. Specifically, in response to:  *
  *                        *
  *     WM_CREATE  -Allocates for and sets up a LOGPALETTE        *
  *           structure, creates a logical palette the same    *
  *           size as the physical palette and obtains a       *
  *           handle to the logical palette.          *
  *                        *
  *     WM_DESTROY -Destroys the logical palette and shuts down app. *
  *                        *
  *     WM_PAINT   -Resizes client area to hold as many vertical     *
  *           color bars as there are physical palette entries.*
  *           Also realises the current logical palette and    *
  *           draws one color bar corresponding to each        *
  *           palette entry              *
  *                        *
  *       WM_RBUTTONDOWN -Captures the mouse and initiates the below       *
  *           process:                *
  *                        *
  *       WM_MOUSEMOVE   -Following a WM_RBUTTONDOWN, if the right mouse   *
  *           key is depressed, displays info about the        *
  *           pixel RGB value and palette index of the mouse   *
  *           coordinates.              *
  *                        *
  *       WM_RBUTTONUP   -Release mouse capture and terminates the above   *
  *           process                *
  *                        *
  *       WM_LBUTTONDOWN -Determines and displays the palette index and    *
  *           RGB value of the bar under the mouse.        *
  *                        *
  *       WM_KEYDOWN     -Allows use of the arrow keys in stepping thro'   *
  *           palette entries.              *
  *                        *
  ****************************************************************************
 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)

 HWND   hWnd;
 unsigned iMessage;
 WORD   wParam;
 LONG   lParam;

 {
     HDC     hDC;
     PAINTSTRUCT   ps;
     WORD    iLoop;
     WORD    nStart;
     HMENU    hMenu;
     HBRUSH    hBrush;
     HBRUSH    hOldBrush;

     POINT    pt;
     static WORD   nIncr;
     static DWORD  dwColor;
     static DWORD  dwLastColor;
     static int    i, x;

     switch (iMessage){
    case WM_DESTROY:
         /* delete the handle to the logical palette if it has any
          * color entries and quit.
          */
         if (pLogPal->palNumEntries)
       DeleteObject (hPal);
         PostQuitMessage (0) ;
         break ;

    case WM_CREATE:
         /* Allocate enough memory for a logical palette with
          * PALETTESIZE entries and set the size and version fields
          * of the logical palette structure.
          */
         pLogPal = (NPLOGPALETTE) LocalAlloc (LMEM_FIXED,
               (sizeof (LOGPALETTE) +
               (sizeof (PALETTEENTRY) * (PALETTESIZE))));

         pLogPal->palVersion    = 0x300;
         pLogPal->palNumEntries = PALETTESIZE;

         /* fill in intensities for all palette entry colors */
         for (iLoop = 0; iLoop < PALETTESIZE; iLoop++) {
       *((WORD *) (&pLogPal->palPalEntry[iLoop].peRed)) = iLoop;
       pLogPal->palPalEntry[iLoop].peBlue  = 0;
       pLogPal->palPalEntry[iLoop].peFlags = PC_EXPLICIT;
         }

         /*  create a logical color palette according the information
          *  in the LOGPALETTE structure.
          */
         hPal = CreatePalette ((LPLOGPALETTE) pLogPal) ;
         break;

    case WM_GETMINMAXINFO:

         ((LPRGPT)lParam)->iInfo[6] = nXBorder * 2 + PALETTESIZE;
         ((LPRGPT)lParam)->iInfo[7] = nXBorder * 2 + nYTitle*3;

         return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
         break;

    case WM_PAINT:

         /* Divide client width into equal-sized parts, one per palette
          * entry, and re-calculate client width so that it will display
          * exactly as many vertical bars as there are palette entries.
          */
          GetClientRect(hWnd,(LPRECT) &rClientRect);
          nSizeX = (rClientRect.right - rClientRect.left);
          nSizeX = (nSizeX/iNumColors) * iNumColors;

          nSizeY = rClientRect.bottom - rClientRect.top;
          GetWindowRect(hWnd,(LPRECT) &rClientRect);

         /* Adjust window width so that it can display exactly
          * as many vertical bars( of equal width) as there are palette
          * colors.
          */

         SetWindowPos( hWnd,
           (HWND)NULL,
           0,
           0,
           nSizeX + 2*nXBorder,
           rClientRect.bottom - rClientRect.top,
           SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);

         hDC = BeginPaint(hWnd, &ps);

         /* Select the palette into the window device context and
          * make the Palette Manager map the logical palette to the
          * system palette (realize it).
          */
         SelectPalette (hDC, hPal, 1);
         RealizePalette (hDC);

         /* Calculate width of each color bar to be displayed */
         nIncr = nSizeX / iNumColors;

         /* Paint the individual bars separately on the app. window */
         for (nStart = iLoop = 0; iLoop < iNumColors; iLoop++){

       /* Since this app. uses a logical palette, use the
        * PALETTEINDEX macro to specify the palette entry
        * index instead of using an explicit RGB value.
        */
       hBrush       = CreateSolidBrush (PALETTEINDEX (iLoop));
       dwPal[iLoop] = GetNearestColor (hDC, PALETTEINDEX (iLoop) );
       hOldBrush    = SelectObject (hDC,hBrush) ;
       PatBlt (hDC, nStart, 0, nIncr, nSizeY, PATCOPY);
       nStart       += nIncr;
       SelectObject (hDC, hOldBrush);
       DeleteObject (hBrush) ;
         }
         wsprintf (szTitlebuf, "MyPal Colors= %d", iNumColors);
         SetWindowText (hWnd, (LPSTR)szTitlebuf);

         EndPaint(hWnd,&ps);

         break ;

    case WM_MOUSEMOVE:

         if (wParam & MK_RBUTTON) {

       /* Convert mouse position to screen coordinates */
       pt.x = LOWORD(lParam);
       pt.y = HIWORD(lParam);
       ClientToScreen(hWnd,&pt);

       /* Get RGB value (color) of pixel under mouse coordinate */
       dwColor = GetPixel(hDCGlobal, pt.x, pt.y);

       /* If color value already exists in palette lookup table,
        * obtain it's index.
        */
       for (i=0 ; i < iNumColors ; i++)
           if ( dwColor == dwPal[i] )
         break;
       iIndex = i;

       /* If previous color value was not identical to current one,
        * display color boxes on either side of title bar,
        * the R, G, B values and palette index of current color.
        */
       if (dwColor != dwLastColor) {
           wsprintf ( szTitlebuf,
          "MyPal Colors=%d  Index=%d  R=%3u G=%3u B=%3u",
          iNumColors,
          iIndex,
          (WORD)(BYTE) GetRValue (dwColor),
          (WORD)(BYTE) GetGValue (dwColor),
          (WORD)(BYTE) GetBValue (dwColor));
           SetWindowText (hWnd, (LPSTR)szTitlebuf);
           ShowColor (hWnd, hDCGlobal);
           dwLastColor = dwColor;
       }
         }
         break;

    case WM_RBUTTONDOWN:

         /* Determine number of color bar under mouse, thus the index
          * of color in palette.
          */
         x = LOWORD(lParam);
         iIndex = (x / nIncr );

         wsprintf ( szTitlebuf,
        "MyPal Colors=%d  Index=%d  PalSize=%d RasterCaps:%d",
        iNumColors,
        iIndex,
        iPalSize,
        iRasterCaps );

         SetWindowText (hWnd, (LPSTR)szTitlebuf);

         /* Set mouse capture so that subsequent WM_MOUSEMOVEs
          * (with right mouse button depressed) will allow MyPal
          * to display RGB info anywhere on the screen without losing
          * the focus.
          */
         SetCapture (hWnd);
         bCaptureOn = TRUE;
         hDCGlobal = GetDC(NULL);
         if (hPal) {
       SelectPalette (hDCGlobal, hPal, FALSE);
       RealizePalette (hDCGlobal);
         }
         break;

    case WM_RBUTTONUP:
         /* Stops displaying RGB and palette info and releases mouse
          * capture
          */
         ReleaseDC (NULL, hDCGlobal);
         bCaptureOn = FALSE;
         ReleaseCapture ();
         break;

    case WM_MOVE:
         /* If you have a wide column, this adds 1/2 so X is centered */
         iGlobalXOffset  = LOWORD (lParam);
         iGlobalYOffset  = HIWORD (lParam) + nXBorder;
         break;

    case WM_SIZE:
         iYMiddle = (HIWORD (lParam)/2);
         break;

    case WM_LBUTTONDOWN:
    case WM_KEYDOWN:

        if (iMessage == WM_LBUTTONDOWN){
      /* determine which column was hit by the mouse */
      x = LOWORD(lParam);
      iIndex = (x / nIncr );
        }
        else{
      /* Use arrow keys to step thro' the palette entries */
      switch (wParam) {
          case VK_RIGHT:
          case VK_UP:
           /* go to next (higher) palette entry */
           iIndex++;
           break;
          case VK_LEFT:
          case VK_DOWN:
           /* go to previous (lower) palette entry */
           iIndex--;
           break;
          case VK_NEXT:
           iIndex += 10;
           break;
          case VK_PRIOR:
           iIndex -= 10;
           break;
          case VK_HOME:
           /* go to first palette entry */
           iIndex = 0;
           break;
          case VK_END:
           /* go to last palette entry */
           iIndex = iNumColors-1;
           break;
          default:
           return 0L;
           break;
      }
      /* Make sure the palette index is within range else
       * set it to the limiting values and give a warning beep.
       */
      if (iIndex < 0) {
          iIndex = 0;
          MessageBeep(1);
      }
      else{
          if (iIndex > iNumColors-1) {
        iIndex = iNumColors-1;
        MessageBeep(1);
           }
      }

      pt.x = (iIndex * nIncr) +
       iGlobalXOffset   +
       ((nIncr > 1) ? (nIncr / 2) : 1);
      pt.y = iYMiddle + iGlobalYOffset;

      SetCursorPos (pt.x, pt.y);
        }

        if (TRUE == bCaptureOn) {
      MessageBeep(1);
      break;
        }

        /* Select & realize the palette or the colors > 0x7
         * will not match up.
         */
        hDC = GetDC(NULL);
        SelectPalette  (hDC, hPal, 1);
        RealizePalette (hDC) ;

        dwColor = GetNearestColor (hDC, PALETTEINDEX (iIndex));

        wsprintf ( szTitlebuf,
       "MyPal Colors=%d  Index=%d  R=%3u G=%3u B=%3u",
       iNumColors,
       iIndex,
       (WORD)(BYTE)GetRValue (dwColor),
       (WORD)(BYTE)GetGValue (dwColor),
       (WORD)(BYTE)GetBValue (dwColor)
          );

        SetWindowText (hWnd, (LPSTR)szTitlebuf);
        ShowColor (hWnd,hDC);
        ReleaseDC(NULL, hDC);
        break;

    default:
         return DefWindowProc (hWnd, iMessage, wParam, lParam) ;

     }
     return 0L ;
 }


 OUTPUT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\OUTPUT\OUTPUT.C

 /****************************************************************************

     PROGRAM: Output.c

     PURPOSE: Output template for Windows applications

     FUNCTIONS:

   WinMain() - calls initialization function, processes message loop
   InitApplication() - initializes window data and registers window
   InitInstance() - saves instance handle and creates main window
   MainWndProc() - processes messages
   About() - processes messages for "About" dialog box

 ****************************************************************************/

 #include "windows.h"
 #include "string.h"
 #include "output.h"

 HANDLE hInst;

 HPEN hDashPen;                                         /* "---" pen handle
 HPEN hDotPen;                                          /* "..." pen handle
 HBRUSH hOldBrush;                                      /* old brush handle
 HBRUSH hRedBrush;                                      /* red brush handle
 HBRUSH hGreenBrush;                                    /* green brush handle
 HBRUSH hBlueBrush;                                     /* blue brush handle


 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
   if (!InitApplication(hInstance))
       return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "OutputMenu";
     wc.lpszClassName = "OutputWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     HWND            hWnd;

     hInst = hInstance;

     hWnd = CreateWindow(
         "OutputWClass",
         "Output Sample Application",
         WS_OVERLAPPEDWINDOW,
   0,
   0,
   GetSystemMetrics(SM_CXSCREEN),
   GetSystemMetrics(SM_CYSCREEN),
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hWnd)
         return (FALSE);

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

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

   WM_COMMAND    - application menu (About dialog box)
   WM_CREATE     - create window and objects
   WM_PAINT      - update window, draw objects
   WM_DESTROY    - destroy window

     COMMENTS:

   Handles to the objects you will use are obtained when the WM_CREATE
   message is received, and deleted when the WM_DESTROY message is
   received.  The actual drawing is done whenever a WM_PAINT message is
   received.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout;

     HDC hDC;                          /* display-context variable  */
     PAINTSTRUCT ps;                   /* paint structure           */
     RECT rcTextBox;                   /* rectangle around the text */
     HPEN hOldPen;                     /* old pen handle            */



     switch (message) {
   case WM_COMMAND:
       if (wParam == IDM_ABOUT) {
     lpProcAbout = MakeProcInstance(About, hInst);

     DialogBox(hInst,
         "AboutBox",
         hWnd,
         lpProcAbout);

     FreeProcInstance(lpProcAbout);
     break;
       }
       else
     return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CREATE:

             /* Create the brush objects */

             hRedBrush =   CreateSolidBrush(RGB(255,   0,   0));
             hGreenBrush = CreateSolidBrush(RGB(  0, 255,   0));
             hBlueBrush =  CreateSolidBrush(RGB(  0,   0, 255));

             /* Create the "---" pen */

             hDashPen = CreatePen(PS_DASH,                /* style */
                 1,                                       /* width */
                 RGB(0, 0, 0));                           /* color */

             /* Create the "..." pen */

             hDotPen = CreatePen(2,                       /* style */
                 1,                                       /* width */
                 RGB(0, 0, 0));                           /* color */
             break;

         case WM_PAINT:
             {
     TEXTMETRIC textmetric;
     int nDrawX;
     int nDrawY;
     char szText[300];

     /* Set up a display context to begin painting */

                 hDC = BeginPaint (hWnd, &ps);

                 /* Get the size characteristics of the current font.  */
                 /* This information will be used for determining the  */
                 /* vertical spacing of text on the screen.            */

                 GetTextMetrics (hDC, &textmetric);

                 /* Initialize drawing position to 1/4 inch from the top  */
                 /* and from the left of the top, left corner of the      */
                 /* client area of the main windows.                      */

                 nDrawX = GetDeviceCaps (hDC, LOGPIXELSX) / 4;   /* 1/4 inch *
                 nDrawY = GetDeviceCaps (hDC, LOGPIXELSY) / 4;   /* 1/4 inch *

                 /* Send characters to the screen.  After displaying each   */
                 /* line of text, advance the vertical position for the     */
                 /* next line of text.  The pixel distance between the top  */
                 /* of each line of text is equal to the standard height of */
                 /* the font characters (tmHeight), plus the standard       */
                 /* amount of spacing (tmExternalLeading) between adjacent  */
                 /* lines.                                                  */

                 strcpy (szText, "These characters are being painted using ");
                 TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
                 nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;

                 strcpy (szText, "the TextOut() function, which is fast and ")
                 TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
                 nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;

                 strcpy (szText, "allows programmer control of placement and "
                 TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
                 nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;

                 strcpy (szText, "formatting details.  However, TextOut() ");
                 TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
                 nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;

                 strcpy (szText, "does not provide any automatic formatting.")
                 TextOut (hDC, nDrawX, nDrawY, szText, strlen (szText));
                 nDrawY += textmetric.tmExternalLeading + textmetric.tmHeight;

                 /* Put text in a 5-inch by 1-inch rectangle and display it. *
                 /* First define the size of the rectangle around the text   *

                 nDrawY += GetDeviceCaps (hDC, LOGPIXELSY) / 4;  /* 1/4 inch *
                 SetRect (
                       &rcTextBox
                     , nDrawX
                     , nDrawY
                     , nDrawX + (5 * GetDeviceCaps (hDC, LOGPIXELSX)) /* 5" */
                     , nDrawY + (1 * GetDeviceCaps (hDC, LOGPIXELSY)) /* 1" */
                 );

                 /* Draw the text within the bounds of the above rectangle */

                 strcpy (szText, "This text is being displayed with a single "
                             "call to DrawText().  DrawText() isn't as fast "
                             "as TextOut(), and it is somewhat more "
                             "constrained, but it provides numerous optional "
                             "formatting features, such as the centering and "
                             "line breaking used in this example.");
                 DrawText (
                       hDC
                     , szText
                     , strlen (szText)
                     , &rcTextBox
                     , DT_CENTER | DT_EXTERNALLEADING | DT_NOCLIP
                                                 | DT_NOPREFIX | DT_WORDBREAK
                 );

                 /*  Paint the next object immediately below the bottom of   *
                 /*  the above rectangle in which the text was drawn.        *

                 nDrawY = rcTextBox.bottom;

                 /* The (x,y) pixel coordinates of the objects about to be   *
                 /* drawn are below, and to the right of, the current        *
                 /* coordinate (nDrawX,nDrawY).                              *

                 /* Draw a red rectangle.. */

                 hOldBrush = SelectObject(hDC, hRedBrush);
                 Rectangle (
                       hDC
                     , nDrawX
                     , nDrawY
                     , nDrawX + 50
                     , nDrawY + 30
                 );

                 /* Draw a green ellipse */

                 SelectObject(hDC, hGreenBrush);
                 Ellipse (
                       hDC
                     , nDrawX + 150
                     , nDrawY
                     , nDrawX + 150 + 50
                     , nDrawY + 30
                 );

                 /* Draw a blue pie shape */

                 SelectObject(hDC, hBlueBrush);
                 Pie (
                       hDC
                     , nDrawX + 300
                     , nDrawY
                     , nDrawX + 300 + 50
                     , nDrawY + 50
                     , nDrawX + 300 + 50
                     , nDrawY
                     , nDrawX + 300 + 50
                     , nDrawY + 50
                 );

                 nDrawY += 50;

                 /* Restore the old brush */

                 SelectObject(hDC, hOldBrush);

                 /* Select a "---" pen, save the old value */

                 nDrawY += GetDeviceCaps (hDC, LOGPIXELSY) / 4;  /* 1/4 inch *
                 hOldPen = SelectObject(hDC, hDashPen);

                 /* Move to a specified point */

                 MoveTo(hDC, nDrawX, nDrawY);

                 /* Draw a line */

                 LineTo(hDC, nDrawX + 350, nDrawY);

                 /* Select a "..." pen */

                 SelectObject(hDC, hDotPen);

                 /* Draw an arc connecting the line */

                 Arc (
                       hDC
                     , nDrawX
                     , nDrawY - 20
                     , nDrawX + 350
                     , nDrawY + 20
                     , nDrawX
                     , nDrawY
                     , nDrawX + 350
                     , nDrawY
                 );

                 /* Restore the old pen */

                 SelectObject(hDC, hOldPen);

                 /* Tell Windows you are done painting */

                 EndPaint (hWnd,  &ps);
             }
             break;

   case WM_DESTROY:
             DeleteObject(hRedBrush);
             DeleteObject(hGreenBrush);
             DeleteObject(hBlueBrush);
             DeleteObject(hDashPen);
             DeleteObject(hDotPen);
       PostQuitMessage(0);
       break;

   default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

   WM_INITDIALOG - initialize dialog box
   WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 OWNCOMBO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\OWNCOMBO\OWNCOMBO.C

 /***************************************************************************
  *                     *
  *  PROGRAM  : OwnCombo.c               *
  *                     *
  *  PURPOSE  : Illustrates the use of functions and messages for     *
  *      combo boxes and owner-draw control styles.       *
  *                     *
  *  FUNCTIONS  : WinMain                - Creates the app. window and     *
  *             enters the message loop.     *
  *                     *
  *      OwnComboInit           - Registers the main window class *
  *                     *
  *      About                  - Dialog function for the About   *
  *             dialog.         *
  *                     *
  *      OwnComboWndProc        - Window function for app. It     *
  *             handles the menu selections     *
  *             and processes the other window  *
  *             messages.         *
  *                     *
  *                DrawEntireItem         - Handles the drawing of a list   *
  *                                         list box or combo box item.     *
  *                     *
  *                HandleSelectionState   - Handles the selecting/deselect- *
  *                                         ing of a list box or combo box  *
  *                                         item.                           *
  *                     *
  *                HandleFocusState       - Handles the getting/losing of   *
  *                                         the input focus by a list box   *
  *                     *
  *      ListBoxExample         - Dialog function for the     *
  *             owner-draw list box example.    *
  *                     *
  *      ComboBoxExample        - Dialog function for the text    *
  *             combo dialog.       *
  *                     *
  *      OwnerComboBoxExample   - Dialog fubction for the drop-   *
  *             down-list combobox with     *
  *             ownerdraw.         *
  *                     *
  ***************************************************************************/
 #include "windows.h"
 #include "owncombo.h"

 HANDLE  hInst;

 /****************************************************************************
  *                      *
  *  FUNCTION   : WinMain(HANDLE, HANDLE, LPSTR, int)          *
  *                      *
  *  PURPOSE    : Creates the app. window and enters the message loop.      *
  *                      *
  ****************************************************************************
 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     HWND  hWnd;
     MSG   msg;

     if (!hPrevInstance)
   if (!OwnComboInit (hInstance))
       return (NULL);

     hInst = hInstance;

     /* Create the app. window */
     hWnd = CreateWindow ("owncombo",
        "Owner-draw & Combo Box Example",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        (HWND) NULL,
        NULL,
        hInstance,
        (LPSTR) NULL);

     if (!hWnd)
   return (NULL);

     ShowWindow (hWnd, nCmdShow);

     while (GetMessage (&msg, NULL, NULL, NULL)){
   TranslateMessage (&msg);
   DispatchMessage (&msg);
     }

     return(msg.wParam);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : OwnComboInit (hInstance)            *
  *                      *
  *  PURPOSE    : Registers the main window class.          *
  *                      *
  *  RETURNS    : TRUE  - if RegisterClass () succeeds.          *
  *     FALSE - if RegisterClass () fails.          *
  *                      *
  ****************************************************************************
 BOOL NEAR PASCAL OwnComboInit (hInstance)

 HANDLE hInstance;
 {
     HANDLE     hMemory;
     PWNDCLASS  pWndClass;
     BOOL       bSuccess;

     /* Allocate for and fill class structure. */
     hMemory = LocalAlloc (LPTR, sizeof (WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock (hMemory);

     pWndClass->style       = NULL;
     pWndClass->lpfnWndProc   = OwnComboWndProc;
     pWndClass->hInstance     = hInstance;
     pWndClass->hIcon       = LoadIcon (hInstance, "owncombo");
     pWndClass->hCursor       = LoadCursor (NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH);
     pWndClass->lpszMenuName  = (LPSTR) "OwnComboMenu",
     pWndClass->lpszClassName = (LPSTR) "owncombo";

     bSuccess = RegisterClass (pWndClass);
     LocalUnlock (hMemory);
     LocalFree (hMemory);

     return (bSuccess);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : About (hDlg,message, wParam, lParam)          *
  *                      *
  *  PURPOSE    : Dialog function for the About... dialog.        *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL About (hDlg, message, wParam, lParam)

 HWND   hDlg;
 unsigned message;
 WORD   wParam;
 LONG   lParam;

 {
     switch (message){
   case WM_INITDIALOG:
       return(TRUE);

   case WM_COMMAND:
       if (wParam == IDOK){
     EndDialog (hDlg,NULL);
     return(FALSE);
       }
       break;

   default:
       break;
     }
   return(FALSE);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : OwnComboWndProc(hWnd, message, wParam, lParam)       *
  *                      *
  *  PURPOSE    : Window function for the app. It handles menu selections    *
  *     and processes window WM_ messages.          *
  *                      *
  ****************************************************************************
 long FAR PASCAL OwnComboWndProc (hWnd, message, wParam, lParam)

 HWND   hWnd;
 unsigned message;
 WORD   wParam;
 LONG   lParam;

 {
     FARPROC       lpProc;
     HMENU       hMenu;
     LPDRAWITEMSTRUCT dis;
     RECT       rc;

     switch (message){
   case WM_COMMAND:
       switch (wParam){
     case IDM_EXIT:
         DestroyWindow (hWnd);
         break;

     case IDM_ABOUT:
         /* Bring up the about box */
         lpProc = MakeProcInstance (About, hInst);
         DialogBox (hInst,
              "AboutBox",
              hWnd,
              lpProc);

         FreeProcInstance (lpProc);
         break;

     case IDM_LISTBOX:
         /* Bring up the list box example */
         lpProc = MakeProcInstance (ListBoxExample, hInst);
         DialogBox (hInst,
              "ListBoxDialog",
              hWnd,
              lpProc);
         FreeProcInstance (lpProc);
         break;

     case IDM_MULTILISTBOX:
         /* Bring up the multiple selection list box example */
         lpProc = MakeProcInstance (ListBoxExample, hInst);
         DialogBox (hInst,
              "MultiListBoxDialog",
              hWnd,
              lpProc);
         FreeProcInstance (lpProc);
         break;

     case IDM_COMBOBOX:
         /* Bring up the combo box example */
         lpProc = MakeProcInstance (ComboBoxExample, hInst);
         DialogBox (hInst,
              "ComboBoxDialog",
              hWnd,
              lpProc);
         FreeProcInstance (lpProc);
         break;

     case IDM_OWNERCOMBOBOX:
         /* Bring up the owner-draw dropdown list box example */
         lpProc = MakeProcInstance (OwnerComboBoxExample, hInst);
         DialogBox (hInst,
              "OwnerComboBoxDialog",
              hWnd,
              lpProc);
         FreeProcInstance (lpProc);
         break;
       }
       break;

   case WM_DESTROY:
       PostQuitMessage (0);
       break;

   default:
       return(DefWindowProc(hWnd, message, wParam, lParam));
     }
     return(NULL);
 }

 /****************************************************************************
  *                                                                          *
  *  FUNCTION   : HandleSelectionState(LPDRAWITEMSTRUCT, int)                *
  *                                                                          *
  *  PURPOSE    : Handles a change in an item selection state. If an item is *
  *               selected, a black rectangular frame is drawn around that   *
  *               item; if an item is de-selected, the frame is removed.     *
  *                                                                          *
  *  COMMENT    : The black selection frame is slightly larger than the gray *
  *               focus frame so they won't paint over each other.           *
  *                                                                          *
  ****************************************************************************
 void FAR PASCAL HandleSelectionState(lpdis, inflate)
   LPDRAWITEMSTRUCT  lpdis;
   int      inflate;
 {
   RECT  rc;
   HBRUSH  hbr;

   /* Resize rectangle to place selection frame outside of the focus
    * frame and the item.
    */
   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem);
   InflateRect ((LPRECT)&rc, inflate, inflate);

   if (lpdis->itemState & ODS_SELECTED)
   {
     /* selecting item -- paint a black frame */
     hbr = GetStockObject(BLACK_BRUSH);
   }
   else
   {
     /* de-selecting item -- remove frame */
     hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
   }
   FrameRect(lpdis->hDC, (LPRECT)&rc, hbr);
   DeleteObject (hbr);
 }

 /****************************************************************************
  *                                                                          *
  *  FUNCTION   : HandleFocusState(LPDRAWITEMSTRUCT, int)                    *
  *                                                                          *
  *  PURPOSE    : Handle a change in item focus state. If an item gains the  *
  *               input focus, a gray rectangular frame is drawn around that *
  *               item; if an item loses the input focus, the gray frame is  *
  *               removed.                                                   *
  *                                                                          *
  *  COMMENT    : The gray focus frame is slightly smaller than the black    *
  *               selection frame so they won't paint over each other.       *
  *                                                                          *
  ****************************************************************************
 void FAR PASCAL HandleFocusState(lpdis, inflate)
   LPDRAWITEMSTRUCT  lpdis;
   int      inflate;
 {
   RECT  rc;
   HBRUSH  hbr;

   /* Resize rectangle to place focus frame between the selection
    * frame and the item.
    */
   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem);
   InflateRect ((LPRECT)&rc, inflate, inflate);

   if (lpdis->itemState & ODS_FOCUS)
   {
     /* gaining input focus -- paint a gray frame */
     hbr = GetStockObject(GRAY_BRUSH);
   }
   else
   {
     /* losing input focus -- remove (paint over) frame */
     hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
   }
   FrameRect(lpdis->hDC, (LPRECT)&rc, hbr);
   DeleteObject (hbr);
 }

 /****************************************************************************
  *                                                                          *
  *  FUNCTION   : DrawEntireItem(LPDRAWITEMSTRUCT, int)                      *
  *                                                                          *
  *  PURPOSE    : Draws an item and frames it with a selection frame and/or  *
  *               a focus frame when appropriate.                            *
  *                                                                          *
  ****************************************************************************
 void FAR PASCAL DrawEntireItem(lpdis, inflate)
   LPDRAWITEMSTRUCT  lpdis;
   int      inflate;
 {
   RECT  rc;
   HBRUSH  hbr;

   /* Resize rectangle to leave space for frames */
   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem);
   InflateRect ((LPRECT)&rc, inflate, inflate);

   /* Create a brush using the value in the item data field (this value
    * was initialized when we added the item to the list/combo box using
    * LB_ADDSTRING/CB_ADDSTRING) and draw the color in the list/combo box.
    */
   hbr = CreateSolidBrush (lpdis->itemData);
   FillRect (lpdis->hDC, (LPRECT)&rc, hbr);
   DeleteObject (hbr);

   /* Draw or erase appropriate frames */
   HandleSelectionState(lpdis, inflate + 4);
   HandleFocusState(lpdis, inflate + 2);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : ListBoxExample (hDlg, message, wParam, lParam)       *
  *                      *
  *  PURPOSE    : Dialog function for the owner-draw list box example.      *
  *     It sets up the example dialog with the owner-draw list box,*
  *     adds the colors to the list box, and handles setting the   *
  *     selection and focus for the items.                         *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL ListBoxExample (hDlg, message, wParam, lParam)

 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;

 {
     LPDRAWITEMSTRUCT  lpdis;
     LPMEASUREITEMSTRUCT lpmis;

     /* Vars for WM_DRAWITEM */
     RECT    rc;
     HBRUSH    hbr;

     switch (message){
   case WM_COMMAND:
       switch (wParam){
     case IDOK:
        EndDialog (hDlg, NULL);
        return (TRUE);
        break;

     /* Clicking any of these buttons adds the corresponding color
      * to the list box. The application-supplied data is the RGB
      * value for the color to be drawn in the listbox.
      */
     case ID_BLACK:
         SendMessage (GetDlgItem (hDlg, ID_LISTBOX),
          LB_ADDSTRING,
          0,
          RGB (0,0,0));
         return(TRUE);
         break;
     case ID_RED:
         SendMessage (GetDlgItem (hDlg, ID_LISTBOX),
          LB_ADDSTRING,
          0,
          RGB (255,0,0));
         return(TRUE);
         break;

     case ID_BLUE:
         SendMessage (GetDlgItem (hDlg, ID_LISTBOX),
          LB_ADDSTRING,
          0,
          RGB (0,0,255));
         return(TRUE);
         break;

     case ID_GREEN:
         SendMessage (GetDlgItem (hDlg, ID_LISTBOX),
          LB_ADDSTRING,
          0,
          RGB (0,255,0));
         return(TRUE);
         break;

     default:
         return(FALSE);
         break;
       }

   case WM_DRAWITEM:
       /* Get pointer to the DRAWITEMSTRUCT */
       lpdis = (LPDRAWITEMSTRUCT)lParam;

       if (lpdis->itemID == -1)
       {
     /* We have a request to draw an item in the list box, yet there
      * are no list box items. This is sent when the user TABS into
      * an empty list box or an empty list box gets the focus. We
      * have to indicate (somehow) that this owner-draw list box has
      * the focus. We do it in response to this message. Note that
      * lpdis->itemData field would be invalid in this instance so
      * we can't allow it to fall into our standard routines.
      */
     HandleFocusState(lpdis, -5);
       }
       else
       {
     switch (lpdis->itemAction)
     {
       case ODA_DRAWENTIRE:
         DrawEntireItem(lpdis, -7);
         break;

       case ODA_SELECT:
         HandleSelectionState(lpdis, -3);
         break;

       case ODA_FOCUS:
         HandleFocusState(lpdis, -5);
         break;
     }
       }

       /* Return TRUE meaning that we processed this message. */
       return(TRUE);
       break;

   case WM_MEASUREITEM:
       lpmis = (LPMEASUREITEMSTRUCT)lParam;

       /* All the items are the same height since the list box style is
        * LBS_OWNERDRAWFIXED
        */
       lpmis->itemHeight = 30;
       break;

   case WM_CLOSE:
       EndDialog(hDlg, NULL);
       return(TRUE);
       break;

   default:
       return(FALSE);
     }

     return(TRUE);
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : ComboBoxExample(hWnd, message, wParam, lParam)       *
  *                      *
  *  PURPOSE    : Dialog function for the text combo dialog. The push buttons*
  *     send various messages to the combo box and the edit control*
  *     when selected. They allow the user to vary data sent with  *
  *     each message.                *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL ComboBoxExample(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {

     HWND hWndCombo;         /* Handle to the combo box control */
              /* in the dialog box window        */
     HWND hWndCheckBox;         /* Handle to the Auto Check Box    */
     char strSingleEditLine[255];     /* Single line edit control input  */
     int  wIndex, wCount;

     /* Get handles to the Combo box and the Check box */
     hWndCombo    = GetDlgItem(hDlg, ID_COMBOBOX);
     hWndCheckBox  = GetDlgItem(hDlg, ID_STEPSBOX);

     switch (message){
   case WM_COMMAND:
       switch (wParam){
     case IDOK:
         EndDialog (hDlg,NULL);
         return(TRUE);

     case ID_UNSLBUTTON:
         /* Selecting this button unselects any selection in the
          * combo box.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wIndex = (WORD) SendMessage( hWndCombo, CB_GETCURSEL, NULL, 0L);
         if (wIndex == CB_ERR)
       MessageBox (hDlg, (LPSTR)"No Selection", NULL, MB_OK);
         else
       SendMessage (hWndCombo, CB_SETCURSEL, -1, 0L);
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_NUMSELBUTTON:
         /* An integer value is taken from the edit control and an
          * attempt is made to select a combo box entry having this
          * index.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wCount = (WORD) SendMessage (hWndCombo, CB_GETCOUNT, 0, 0L);
         wIndex = (int) GetDlgItemInt (hDlg, ID_SINGLEEDIT, NULL, TRUE);
         if (wIndex >= wCount)
       MessageBox (hDlg, (LPSTR)"Bad Selection", NULL, MB_OK);
         else
       SendMessage(hWndCombo, CB_SETCURSEL, wIndex, 0L);
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_TXTSELBUTTON:
         /* A text string is taken from the edit control and an
          * attempt is made to select a combo box entry having the
          * string as a prefix.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         GetDlgItemText (hDlg, ID_SINGLEEDIT,
          (LPSTR)strSingleEditLine, 255);
         wIndex = (WORD) SendMessage (hWndCombo,
             CB_SELECTSTRING,
             -1,
             (LONG)(LPSTR)strSingleEditLine);
         if (wIndex == CB_ERR)
           MessageBox (hDlg, (LPSTR)"Bad Selection", NULL, MB_OK);
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_FNDSELBUTTON:
         /* Searches for the text specified in the list of combo
          * entries and returns the index (in combo box) of the
          * first match. The index is displayed in the "Text1"
          * field of the dialog.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         GetDlgItemText (hDlg,
             ID_SINGLEEDIT,
             (LPSTR)strSingleEditLine,
             255);
         wIndex = (WORD)SendMessage (hWndCombo,
                  CB_FINDSTRING,-1,
                  (LONG)(LPSTR)strSingleEditLine);
         if (wIndex == CB_ERR)
       MessageBox (hDlg, (LPSTR)"Bad Selection", NULL, MB_OK);
         else
       SetDlgItemInt (hDlg, ID_TEXT1, wIndex, FALSE);
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_CLRBUTTON:
         /* Clears the combo box of all it's entries */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wCount = (WORD) SendMessage (hWndCombo, CB_GETCOUNT, 0, 0L);
         if (!wCount)
       MessageBox (hDlg, (LPSTR)"Already clear", NULL, MB_OK);
         else{
       SetDlgItemInt (hDlg, ID_TEXT1, wCount, TRUE);
       SetDlgItemText (hDlg, ID_TEXT2, "Items cleared");
       SendMessage (hWndCombo,CB_RESETCONTENT, 0, 0L);
         }
         SetFocus (GetDlgItem (hDlg,ID_SINGLEEDIT));
         break;

     case ID_ADDBUTTON:
         /* Takes the string specified in the edit control and
          * adds it to the combo box.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         GetDlgItemText (hDlg, ID_SINGLEEDIT, strSingleEditLine, 255);
         SendMessage (hWndCombo,
          CB_ADDSTRING,
          0,
          (LONG)(LPSTR) strSingleEditLine);
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_DELETEBUTTON:
         /* Delete the currently selected item from the combo box. */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wIndex = (WORD) SendMessage (hWndCombo, CB_GETCURSEL, 0, 0L);
         if (SendMessage (hWndCombo, CB_DELETESTRING, wIndex, 0L) == CB_ERR)
       MessageBox (hDlg, (LPSTR)"No Selection", NULL, MB_OK);
         else{
       SetDlgItemText (hDlg, ID_TEXT1, "deleted index #");
       SetDlgItemInt  (hDlg, ID_TEXT2, wIndex, TRUE);
         }
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     case ID_CBDIRBUTTON:
         /* Appends a directory listing of the current directory
          * to the combo box entries.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wIndex = (WORD)SendMessage (hWndCombo,
                  CB_DIR,
                  0x10|0x4000,
                  (LONG)(LPSTR)"*.*");
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;


     case ID_CPYBUTTON:
         /* Copies the currently selected item in the combo box to
          * the edit control.
          */
         SetDlgItemText (hDlg, ID_TEXT1, "");
         SetDlgItemText (hDlg, ID_TEXT2, "");
         wIndex = (WORD) SendMessage (hWndCombo, CB_GETCURSEL, 0, 0L);
         if (wIndex == CB_ERR)
       MessageBox(hDlg, (LPSTR)"No Selection", NULL, MB_OK);
         else{
       wCount = SendMessage (hWndCombo, CB_GETLBTEXTLEN, wIndex, 0L);
       SendMessage (hWndCombo,
              CB_GETLBTEXT,
              wIndex,
              (LONG)(LPSTR)strSingleEditLine);
       SetDlgItemText(hDlg, ID_SINGLEEDIT,
                (LPSTR)strSingleEditLine);
       SetDlgItemText(hDlg, ID_TEXT1, "copied index #");
       SetDlgItemInt(hDlg, ID_TEXT2, wIndex, TRUE);
         }
         SetFocus (GetDlgItem (hDlg, ID_SINGLEEDIT));
         break;

     /* When the combo notification box is checked, a message box
      * is flashed showing what notification codes the combo box is
      * returning to the app. in response to the messages sent by
      * the buttons.
      */
     case ID_COMBOBOX:
         if (SendMessage (hWndCheckBox, BM_GETCHECK, 0, 0L)){
       switch (HIWORD(lParam)){
           case (WORD)CBN_ERRSPACE:
             MessageBox (hDlg, (LPSTR)"CB Out of Space",
            "CB MSG", MB_OK);
             break;

           case CBN_SELCHANGE:
             MessageBox (hDlg, (LPSTR)"CB Sel Change",
            "CB MSG", MB_OK);
             break;

           case CBN_DBLCLK:
             MessageBox(hDlg, (LPSTR)"CB Double Click",
            "CB MSG", MB_OK);
             break;

           case CBN_SETFOCUS:
             SetDlgItemText(hDlg, ID_TEXT1, "CB SetFocus");
             break;

           case CBN_KILLFOCUS:
             SetDlgItemText(hDlg, ID_TEXT1, "CB KillFocus");
             break;
       }
         }
         break;

     default:
         return(FALSE);
       }
       break;

   case WM_CLOSE:
       EndDialog(hDlg, NULL);
       return(TRUE);
       break;

   default:
       return(FALSE);
     }
     return(TRUE);
 }


 /****************************************************************************
  *                      *
  *  FUNCTION   : OwnerComboBoxExample(hWnd, message, wParam, lParam)      *
  *                      *
  *  PURPOSE    : Dialog function for the dropdown list combo box with      *
  *     owner-draw.                *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL OwnerComboBoxExample (hDlg, message, wParam, lParam)

 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     LPDRAWITEMSTRUCT  lpdis;
     LPMEASUREITEMSTRUCT lpmis;

     /* Variables for WM_DRAWITEM */
     RECT    rc;
     HBRUSH    hbr;

     switch (message){
   case WM_COMMAND:
       switch (wParam){
     case IDOK:
        EndDialog (hDlg, NULL);
        return(TRUE);
        break;

     /* Clicking any of these buttons adds the corresponding color
      * to the combo box. The application-supplied data is the RGB
      * value for the color to be drawn in the listbox.
      */
     case ID_BLACK:
        SendMessage (GetDlgItem(hDlg, ID_LISTBOX),
         CB_ADDSTRING,
         0,
         RGB (0,0,0));
        return(TRUE);
        break;

     case ID_RED:
        SendMessage (GetDlgItem (hDlg, ID_LISTBOX),
         CB_ADDSTRING,
         0,
         RGB (255,0,0));
        return(TRUE);
        break;

     case ID_BLUE:
        SendMessage (GetDlgItem(hDlg, ID_LISTBOX),
         CB_ADDSTRING,
         0,
         RGB (0,0,255));
        return(TRUE);
        break;

     case ID_GREEN:
        SendMessage (GetDlgItem(hDlg, ID_LISTBOX),
         CB_ADDSTRING,
         0,
         RGB (0,255,0));
        return(TRUE);
        break;

     default:
        return(TRUE);
        break;
       }

   case WM_DRAWITEM:
       /* Get pointer to the DRAWITEMSTRUCT */
       lpdis = (LPDRAWITEMSTRUCT)lParam;

       if (lpdis->itemID == -1){
     /* We have a request to draw an item in the combo box, yet there
      * are no combo box items. This is sent when the user TABS into
      * an empty combo box or an empty combo box gets the focus. We
      * have to indicate (somehow) that this owner-draw combo box has
      * the focus. We do it in response to this message. Note that
      * lpdis->itemData field would be invalid in this instance so
      * we can't allow it to fall into our standard routines.
      */
     HandleFocusState(lpdis, -2);
       }
       else
       {
     switch (lpdis->itemAction)
     {
       case ODA_DRAWENTIRE:
         DrawEntireItem(lpdis, -4);
         break;

       case ODA_SELECT:
         HandleSelectionState(lpdis, 0);
         break;

       case ODA_FOCUS:
         HandleFocusState(lpdis, -2);
         break;
     }
       }

       /* Return TRUE meaning that we processed this message. */
       return(TRUE);
       break;

   case WM_MEASUREITEM:
       lpmis = (LPMEASUREITEMSTRUCT)lParam;

       /* All the items are the same height since the combo box is
        * CBS_OWNERDRAWFIXED
        */
       if (lpmis->itemID == -1){
     /* If -1 for item, then we are setting the height of the
      * always visible static item part of the dropdown combo box.
      */
     lpmis->itemHeight = 25;
     return(TRUE);
       }
       lpmis->itemHeight = 30;
       break;

   case WM_CLOSE:
       EndDialog(hDlg, NULL);
       return(TRUE);
       break;

   default:
       return(FALSE);
     }
     return(TRUE);
 }


 PRINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\PRINT.C

 /****************************************************************************
  *                         *
  *  MODULE  : Print.c                   *
  *                         *
  *  DESCRIPTION : Routines used for printing.               *
  *                         *
  *  FUNCTIONS  : GetPrinterDC()   - Gets default printer from WIN.INI and
  *             creates a DC for it.           *
  *                         *
  *      InitPrinting()   - Initializes print job.           *
  *                         *
  *      TermPrinting()   - Terminates print job.           *
  *                         *
  *      PrintDlgProc()   - Dialog function for the "Cancel Printing" *
  *             dialog.               *
  *                         *
  *      AbortProc()     - Peeks at message queue for messages from  *
  *             the print dialog.             *
  *                         *
  ****************************************************************************

 #include <windows.h>
 #include <string.h>
 #include "showdib.h"

 FARPROC  lpfnAbortProc    = NULL;
 FARPROC  lpfnPrintDlgProc = NULL;
 HWND   hWndParent    = NULL;
 HWND   hDlgPrint    = NULL;
 BOOL   bError;
 BOOL   bUserAbort;


 BOOL FAR PASCAL AbortProc (HDC, short);
 BOOL FAR PASCAL PrintDlgProc (HWND, unsigned, WORD, DWORD);

 #pragma alloc_text(_PRINT, AbortProc, PrintDlgProc)

 /****************************************************************************
  *                      *
  *  FUNCTION   : GetPrinterDC()               *
  *                      *
  *  PURPOSE    : Read WIN.INI for default printer and create a DC for it.   *
  *                      *
  *  RETURNS    : A handle to the DC if successful or NULL otherwise.      *
  *                      *
  ****************************************************************************
 HDC PASCAL GetPrinterDC()
 {
     static char szPrinter [80];
     char    *szDevice, *szDriver, *szOutput;

     GetProfileString ("windows", "device", "", szPrinter, sizeof(szPrinter));

     if ((szDevice = strtok (szPrinter, "," )) &&
   (szDriver = strtok (NULL,      ", ")) &&
   (szOutput = strtok (NULL,      ", ")))

   return CreateDC (szDriver, szDevice, szOutput, NULL) ;

     return NULL;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : InitPrinting(HDC hDC, HWND hWnd, HANDLE hInst, LPSTR msg)  *
  *                      *
  *  PURPOSE    : Makes preliminary driver calls to set up print job.      *
  *                      *
  *  RETURNS    : TRUE  - if successful.             *
  *     FALSE - otherwise.              *
  *                      *
  ****************************************************************************
 BOOL PASCAL InitPrinting(HDC hDC, HWND hWnd, HANDLE hInst, LPSTR msg)
 {

     bError     = FALSE;     /* no errors yet */
     bUserAbort = FALSE;     /* user hasn't aborted */

     hWndParent = hWnd;      /* save for Enable at Term time */

     lpfnPrintDlgProc = MakeProcInstance (PrintDlgProc, hInst);
     lpfnAbortProc    = MakeProcInstance (AbortProc, hInst);

     hDlgPrint = CreateDialog (hInst, "PRTDLG", hWndParent, lpfnPrintDlgProc);

     if (!hDlgPrint)
   return FALSE;

     SetWindowText (hDlgPrint, msg);
     EnableWindow (hWndParent, FALSE);       /* disable parent */

     if ((Escape (hDC, SETABORTPROC, 0, (LPSTR)lpfnAbortProc, NULL) > 0) &&
   (Escape (hDC, STARTDOC, lstrlen(msg), msg, NULL) > 0))
   bError = FALSE;
     else
   bError = TRUE;

     /* might want to call the abort proc here to allow the user to
      * abort just before printing begins */
     return TRUE;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   :  TermPrinting(HDC hDC)             *
  *                      *
  *  PURPOSE    :  Terminates print job.             *
  *                      *
  ****************************************************************************
 void PASCAL TermPrinting(HDC hDC)
 {
     if (!bError)
   Escape(hDC, ENDDOC, 0, NULL, NULL);

     if (bUserAbort)
   Escape (hDC, ABORTDOC, 0, NULL, NULL) ;
     else {
   EnableWindow(hWndParent, TRUE);
   DestroyWindow(hDlgPrint);
     }

     FreeProcInstance(lpfnAbortProc);
     FreeProcInstance(lpfnPrintDlgProc);
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   :PrintDlgProc (HWND, unsigned , WORD , DWORD )        *
  *                      *
  *  PURPOSE    :Dialog function for the "Cancel Printing" dialog. It sets   *
  *    the abort flag if the user presses <Cancel>.        *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL PrintDlgProc (HWND hDlg, unsigned iMessage, WORD wParam, DWOR
 {
     switch (iMessage) {
     case WM_INITDIALOG:

       EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE, MF_GRAYED);
       break;

     case WM_COMMAND:
       bUserAbort = TRUE;
       EnableWindow (hWndParent, TRUE);
       DestroyWindow (hDlg);
       hDlgPrint = 0;
       break;

     default:
       return FALSE;
     }
     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   :AbortProc (HDC hPrnDC, short nCode)          *
  *                      *
  *  PURPOSE    :Checks message queue for messages from the "Cancel Printing"*
  *    dialog. If it sees a message, (this will be from a print    *
  *    cancel command), it terminates.           *
  *                      *
  *  RETURNS    :Inverse of Abort flag              *
  *                      *
  ****************************************************************************
 BOOL FAR PASCAL AbortProc (HDC hPrnDC, short nCode)
 {
     MSG   msg;

     while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
   if (!hDlgPrint || !IsDialogMessage(hDlgPrint, &msg)) {
       TranslateMessage (&msg);
       DispatchMessage (&msg);
   }
     }
     return !bUserAbort;
 }


 PRNTFILE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\PRNTFILE\PRNTFILE.C

 /****************************************************************************

     PROGRAM: PrntFile.c

     PURPOSE: Loads, saves, and edits text files

     FUNCTIONS:

         WinMain() - calls initialization function, processes message loop
         InitApplication() - initializes window data and registers window
         InitInstance() - saves instance handle and creates main window
         MainWndProc() - processes messages
         About() - processes messages for "About" dialog box
         SaveAsDlg() - save file under different name
         OpenDlg() - let user select a file, and open it.
         UpdateListBox() - Update the list box of OpenDlg
         ChangeDefExt() - Change the default extension
         SeparateFile() - Separate filename and pathname
         AddExt() - Add default extension
         CheckFileName() - Check for wildcards, add extension if needed
         SaveFile() - Save current file
         QuerySaveFile() - Called when some action might lose current contents
         SetNewBuffer() - Set new buffer for edit window

 ****************************************************************************/

 #include "windows.h"
 #include "prntfile.h"

 HANDLE hInst;

 HANDLE hAccTable;                                /* handle to accelerator tab
 HWND hEditWnd;                                      /* handle to edit window
 HWND hwnd;                                       /* handle to main window */

 /* Additional includes needed for the fstat() function */

 #include <sys\types.h>
 #include <sys\stat.h>

 char FileName[128];
 char PathName[128];
 char OpenName[128];
 char DefPath[128];
 char DefSpec[13] = "*.*";
 char DefExt[] = ".txt";
 char str[255];

 HANDLE hEditBuffer;                       /* handle to editing buffer      */
 HANDLE hOldBuffer;                        /* old buffer handle        */
 HANDLE hHourGlass;                        /* handle to hourglass cursor
 HANDLE hSaveCursor;                       /* current cursor handle      */
 int hFile;                                /* file handle              */
 int count;                                /* number of chars read or written
 PSTR pBuffer;                             /* address of read/write buffer
 OFSTRUCT OfStruct;                        /* information from OpenFile()
 struct stat FileStatus;                   /* information from fstat()      */
 BOOL bChanges = FALSE;                    /* TRUE if the file is changed
 BOOL bSaveEnabled = FALSE;                /* TRUE if text in the edit buffer
 PSTR pEditBuffer;                         /* address of the edit buffer
 RECT Rect;                                /* dimension of the client window

 char Untitled[] =                         /* default window title      */
      "Edit File - (untitled)";

 /* Printer variables  */

 HDC hPr;                            /* handle for printer device context
 int LineSpace;                      /* spacing between lines          */
 int LinesPerPage;                   /* lines per page                 */
 int CurrentLine;                    /* current line                   */
 int LineLength;                     /* line length                    */
 DWORD dwLines;                      /* number of lines to print       */
 DWORD dwIndex;                      /* index into lines to print      */
 char pLine[128];                    /* buffer to store lines before printing
 TEXTMETRIC TextMetric;              /* information about character size
 BOOL bAbort;                        /* FALSE if user cancels printing      */
 HWND hAbortDlgWnd;
 FARPROC lpAbortDlg, lpAbortProc;

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;

     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "PrntFileMenu";
     wc.lpszClassName = "PrntFileWClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle and creates main window

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     RECT            Rect;

     hInst = hInstance;

     hAccTable = LoadAccelerators(hInst, "PrntFileAcc");

     hwnd = CreateWindow(
         "PrntFileWClass",
         "PrntFile Sample Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwnd)
         return (FALSE);

     GetClientRect(hwnd, (LPRECT) &Rect);

     /* Create a child window */

     hEditWnd = CreateWindow("Edit",
         NULL,
         WS_CHILD | WS_VISIBLE |
         ES_MULTILINE |
         WS_VSCROLL | WS_HSCROLL |
         ES_AUTOHSCROLL | ES_AUTOVSCROLL,
         0,
         0,
         (Rect.right-Rect.left),
         (Rect.bottom-Rect.top),
         hwnd,
         IDC_EDIT,                          /* Child control i.d. */
         hInst,
         NULL);

     if (!hEditWnd) {
         DestroyWindow(hwnd);
         return (NULL);
     }

     /* Get an hourglass cursor to use during file transfers */

     hHourGlass = LoadCursor(NULL, IDC_WAIT);

     ShowWindow(hwnd, nCmdShow);
     UpdateWindow(hwnd);
     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages

     MESSAGES:

         WM_COMMAND    - application menu (About dialog box)
         WM_DESTROY    - destroy window
         WM_SIZE       - window size has changed
         WM_QUERYENDSESSION - willing to end session?
         WM_ENDSESSION - end Windows session
         WM_CLOSE      - close the window
         WM_SIZE       - window resized

     COMMENTS:

         Adds printing capability to the EDITFILE program.  Printing request
         is sent as an IDM_PRINT message.

         Before the printing operation begins, a modeless dialog box is
         created to allow the user to abort the printing operation.  This
         dialog box remains active until the print job is completed, or the
         user cancels the print operation.

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpOpenDlg, lpSaveAsDlg;

     int Success;                            /* return value from SaveAsDlg()
     int IOStatus;          /* result of file i/o      */
     int nPageSize;          /* vert. resolution of printer device */


     switch (message) {
         case WM_COMMAND:
             switch (wParam) {
                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 case IDM_NEW:

                     /* If current file has been modified, query user about
                      * saving it.
                      */

                     if (!QuerySaveFile(hWnd))
                         return (NULL);

                     /* bChanges is set to FALSE to indicate there have been
                      * no changes since the last file save.
                      */

                     bChanges = FALSE;
                     FileName[0] = 0;

                     /* Update the edit buffer */

                     SetNewBuffer(hWnd, NULL, Untitled);
                     break;

                 case IDM_OPEN:
                     if (!QuerySaveFile(hWnd))
                         return (NULL);

                     lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);

                     /* Open the file and get its handle */

                     hFile = DialogBox(hInst, "Open", hWnd, lpOpenDlg);
                     FreeProcInstance(lpOpenDlg);
                     if (!hFile)
                         return (NULL);

                     /* Allocate edit buffer to the size of the file + 1 */

                     hEditBuffer =
                         LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,
           (WORD)FileStatus.st_size+1);

                     if (!hEditBuffer) {
                         MessageBox(hWnd, "Not enough memory.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (NULL);
                     }
                     hSaveCursor = SetCursor(hHourGlass);
                     pEditBuffer = LocalLock(hEditBuffer);

                     IOStatus = read(hFile, pEditBuffer, FileStatus.st_size);
                     close(hFile);

                     /* # bytes read must equal file size */

                     if (IOStatus != (int)FileStatus.st_size) {

                         sprintf(str, "Error reading %s.", FileName);
                         SetCursor(hSaveCursor);      /* Remove the hourglass
                         MessageBox(hWnd, str, NULL, MB_OK | MB_ICONEXCLAMATIO
                     }

                     LocalUnlock(hEditBuffer);

                     /* Set up a new buffer and window title */

                     sprintf(str, "PrntFile - %s", FileName);
                     SetNewBuffer(hWnd, hEditBuffer, str);
                     SetCursor(hSaveCursor);            /* restore the cursor
                     break;

                 case IDM_SAVE:

                     /* If there is no filename, use the saveas command to get
                      * one.  Otherwise, save the file using the current
                      * filename.
                      */

                     if (!FileName[0])
                         goto saveas;
                     if (bChanges)
                         SaveFile(hWnd);
                     break;

                 case IDM_SAVEAS:
 saveas:
                     lpSaveAsDlg = MakeProcInstance(SaveAsDlg, hInst);

                     /* Call the SaveAsDlg() function to get the new filename

                     Success = DialogBox(hInst, "SaveAs", hWnd, lpSaveAsDlg);
                     FreeProcInstance(lpSaveAsDlg);

                     /* If successful, update the window title, save the file

                     if (Success == IDOK) {
                         sprintf(str, "PrntFile - %s", FileName);
                         SetWindowText(hWnd, str);
                         SaveFile(hWnd);
                     }
                     break;                                  /* User canceled
                 case IDM_PRINT:
                     hSaveCursor = SetCursor(hHourGlass);
                     hPr = GetPrinterDC();
                     if (!hPr) {
                         sprintf(str, "Cannot print %s", FileName);
                         MessageBox(hWnd, str, NULL, MB_OK | MB_ICONHAND);
                         return (NULL);
                     }

                     lpAbortDlg =  MakeProcInstance(AbortDlg, hInst);
                     lpAbortProc = MakeProcInstance(AbortProc, hInst);

                     /* Define the abort function */

                     Escape(hPr, SETABORTPROC, NULL,
                         (LPSTR) (long) lpAbortProc,
                         (LPSTR) NULL);

                     if (Escape(hPr, STARTDOC, 4, "PrntFile text",
                             (LPSTR) NULL) < 0) {
                         MessageBox(hWnd, "Unable to start print job",
                             NULL, MB_OK | MB_ICONHAND);
                         FreeProcInstance(lpAbortDlg);
                         FreeProcInstance(lpAbortProc);
                         DeleteDC(hPr);
                     }

                     bAbort = FALSE; /* Clears the abort flag  */

                     /* Create the Abort dialog box (modeless) */

                     hAbortDlgWnd = CreateDialog(hInst, "AbortDlg",
                         hWnd, lpAbortDlg);

                     if (!hAbortDlgWnd) {
                         SetCursor(hSaveCursor);      /* Remove the hourglass
                         MessageBox(hWnd, "NULL Abort window handle",
                             NULL, MB_OK | MB_ICONHAND);
                         return (FALSE);
                     }

                     /* Now show Abort dialog */

                     ShowWindow (hAbortDlgWnd, SW_NORMAL);

                     /* Disable the main window to avoid reentrancy problems *

                     EnableWindow(hWnd, FALSE);
                     SetCursor(hSaveCursor);      /* Remove the hourglass */

                     /* Since you may have more than one line, you need to
                      * compute the spacing between lines.  You can do that by
                      * retrieving the height of the characters you are printi
                      * and advancing their height plus the recommended extern
                      * leading height.
                      */

                     GetTextMetrics(hPr, &TextMetric);
                     LineSpace = TextMetric.tmHeight +
                         TextMetric.tmExternalLeading;

                     /* Since you may have more lines than can fit on one
                      * page, you need to compute the number of lines you can
                      * print per page.  You can do that by retrieving the
          * dimensions of the page and dividing the height
                      * by the line spacing.
                      */

         nPageSize = GetDeviceCaps (hPr, VERTRES);
         LinesPerPage = nPageSize / LineSpace - 1;


                     /* You can output only one line at a time, so you need a
                      * count of the number of lines to print.  You can retrie
                      * the count sending the EM_GETLINECOUNT message to the e
                      * control.
                      */

                     dwLines = SendMessage(hEditWnd, EM_GETLINECOUNT, 0, 0L);

                     /* Keep track of the current line on the current page */

                     CurrentLine = 1;

                     /* One way to output one line at a time is to retrieve
                      * one line at a time from the edit control and write it
                      * using the TextOut function.  For each line you need to
                      * advance one line space.  Also, you need to check for t
                      * end of the page and start a new page if necessary.
                      */

                     for (dwIndex = IOStatus = 0; dwIndex < dwLines; dwIndex++
                         pLine[0] = 128;               /* Maximum buffer size
                         pLine[1] = 0;
                         LineLength = SendMessage(hEditWnd, EM_GETLINE,
                             (WORD)dwIndex, (LONG)((LPSTR)pLine));
                         TextOut(hPr, 0, CurrentLine*LineSpace,
                             (LPSTR)pLine, LineLength);
                         if (++CurrentLine > LinesPerPage ) {
                             CurrentLine = 1;
                             IOStatus = Escape(hPr, NEWFRAME, 0, 0L, 0L);
                             if (IOStatus<0 || bAbort)
                                 break;
                         }
                     }

                     if (IOStatus >= 0 && !bAbort) {
                         Escape(hPr, NEWFRAME, 0, 0L, 0L);
                         Escape(hPr, ENDDOC, 0, 0L, 0L);
                     }
                     EnableWindow(hWnd, TRUE);

                     /* Destroy the Abort dialog box */

                     DestroyWindow(hAbortDlgWnd);
                     FreeProcInstance(lpAbortDlg);
                     FreeProcInstance(lpAbortProc);
                     DeleteDC(hPr);
                     break;


                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:
                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "PrntFile Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDM_EXIT:
                     QuerySaveFile(hWnd);
                     DestroyWindow(hWnd);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "PrntFile Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SETFOCUS:
             SetFocus (hEditWnd);
             break;

         case WM_SIZE:
             MoveWindow(hEditWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
             break;

         case WM_QUERYENDSESSION:             /* message: to end the session?
             return (QuerySaveFile(hWnd));

         case WM_CLOSE:                       /* message: close the window
             if (QuerySaveFile(hWnd))
                 DestroyWindow(hWnd);
             break;

         case WM_DESTROY:
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 /****************************************************************************

     FUNCTION: SaveAsDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Allows user to change name to save file to

     COMMENTS:

         This will initialize the window class if it is the first time this
         application is run.  It then creates the window, and processes the
         message loop until a PostQuitMessage is received.  It exits the
         application by returning the value passed by the PostQuitMessage.

 ****************************************************************************/

 int FAR PASCAL SaveAsDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     char TempName[128];

     switch (message) {
         case WM_INITDIALOG:

             /* If no filename is entered, don't allow the user to save to it

             if (!FileName[0])
                 bSaveEnabled = FALSE;
             else {
                 bSaveEnabled = TRUE;

                 /* Process the path to fit within the IDC_PATH field */

                 DlgDirList(hDlg, DefPath, NULL, IDC_PATH, 0x4010);

                 /* Send the current filename to the edit control */

                 SetDlgItemText(hDlg, IDC_EDIT, FileName);

                 /* Accept all characters in the edit control */

                 SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, 0,
                     MAKELONG(0, 0x7fff));
             }

             /* Enable or disable the save control depending on whether the
              * filename exists.
              */

             EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled);

             /* Set the focus to the edit control within the dialog box */

             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE);                 /* FALSE since Focus was changed

         case WM_COMMAND:
             switch (wParam) {
                 case IDC_EDIT:

                     /* If there was previously no filename in the edit
                      * control, then the save control must be enabled as soon
                      * a character is entered.
                      */

                     if (HIWORD(lParam) == EN_CHANGE && !bSaveEnabled)
                     EnableWindow(GetDlgItem(hDlg, IDOK), bSaveEnabled = TRUE)
                     return (TRUE);

                 case IDOK:

                    /* Get the filename from the edit control */

                     GetDlgItemText(hDlg, IDC_EDIT, TempName, 128);

                     /* If there are no wildcards, then separate the name into
                      * path and name.  If a path was specified, replace the
                      * default path with the new path.
                      */

                     if (CheckFileName(hDlg, FileName, TempName)) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) FileName);
                         if (str[0])
                             strcpy(DefPath, str);

                         /* Tell the caller a filename was selected */

                         EndDialog(hDlg, IDOK);
                     }
                     return (TRUE);

                 case IDCANCEL:

                     /* Tell the caller the user canceled the SaveAs function

                     EndDialog(hDlg, IDCANCEL);
                     return (TRUE);
             }
             break;

     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: OpenDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Let user select a file, and open it.

 ****************************************************************************/

 HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     WORD index;
     PSTR pTptr;
     HANDLE hFile;

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDC_LISTBOX:
                     switch (HIWORD(lParam)) {

                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
           if (DlgDirSelect(hDlg, str, IDC_LISTBOX)) {
                                 strcat(str, DefSpec);

           }
                             SetDlgItemText(hDlg, IDC_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 IDC_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));


                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                     }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
                     if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) OpenName);
                         if (str[0])
                             strcpy(DefPath, str);
                         ChangeDefExt(DefExt, DefSpec);
                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     if (!OpenName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                     }

                     AddExt(OpenName, DefExt);

                     /* Open the file */

                     if ((hFile = OpenFile(OpenName, (LPOFSTRUCT) &OfStruct,
                             OF_READ)) == -1) {
                         sprintf(str, "Error %d opening %s.",
                             OfStruct.nErrCode, OpenName);
                         MessageBox(hDlg, str, NULL,
                             MB_OK | MB_ICONHAND);
                     }
                     else {

                         /* Make sure there's enough room for the file */

                         fstat(hFile, &FileStatus);

                         if (FileStatus.st_size > MAXFILESIZE) {
                             sprintf(str,
                     "Not enough memory to load %s.\n%s exceeds %ld bytes.",
                                 OpenName, OpenName, MAXFILESIZE);
                             MessageBox(hDlg, str, NULL,
                                 MB_OK | MB_ICONHAND);
                             return (TRUE);
                         }

                         /* File is opened and there is enough room so return
                          * the handle to the caller.
                          */

                         strcpy(FileName, OpenName);
                         EndDialog(hDlg, hFile);
                         return (TRUE);
                     }
                     return (TRUE);

                 case IDCANCEL:
        /* strcpy(DefPath, str);
         ChangeDefExt(DefExt, DefSpec);*/
                     EndDialog(hDlg, NULL);
                     return (TRUE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }

 /****************************************************************************

     FUNCTION: UpdateListBox(HWND);

     PURPOSE: Update the list box of OpenDlg

 ****************************************************************************/

 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* To ensure that the listing is made for a subdir. of
      * current drive dir...
      */
     if (!strchr (DefPath, ':'))
   DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* Remove the '..' character from path if it exists, since this
      * will make DlgDirList move us up an additional level in the tree
      * when UpdateListBox() is called again.
      */
     if (strstr (DefPath, ".."))
   DefPath[0] = '\0';
     SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
 }

 /****************************************************************************

     FUNCTION: ChangeDefExt(PSTR, PSTR);

     PURPOSE: Change the default extension

 ****************************************************************************/

 void ChangeDefExt(Ext, Name)
 PSTR Ext, Name;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr)
         if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
             strcpy(Ext, pTptr);
 }

 /****************************************************************************

     FUNCTION: SeparateFile(HWND, LPSTR, LPSTR, LPSTR)

     PURPOSE: Separate filename and pathname

 ****************************************************************************/

 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;
     char  cTmp;

     lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {
         lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     lstrcpy(lpDestFileName, lpTmp + 1);
     cTmp = *(lpTmp + 1);
     lstrcpy(lpDestPath, lpSrcFileName);
      *(lpTmp + 1) = cTmp;
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }

 /****************************************************************************

     FUNCTION: AddExt(PSTR, PSTR);

     PURPOSE: Add default extension

 /***************************************************************************/

 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }

 /****************************************************************************

     FUNCTION: CheckFileName(HWND, PSTR, PSTR)

     PURPOSE: Check for wildcards, add extension if needed

     COMMENTS:

         Make sure you have a filename and that it does not contain any
         wildcards.  If needed, add the default extension.  This function is
         called whenever your application wants to save a file.

 ****************************************************************************/

 BOOL CheckFileName(hWnd, pDest, pSrc)
 HWND hWnd;
 PSTR pDest, pSrc;
 {
     PSTR pTmp;

     if (!pSrc[0])
         return (FALSE);               /* Indicates no filename was specified

     pTmp = pSrc;
     while (*pTmp) {                     /* Searches the string for wildcards
         switch (*pTmp++) {
             case '*':
             case '?':
                 MessageBox(hWnd, "Wildcards not allowed.",
                     NULL, MB_OK | MB_ICONEXCLAMATION);
                 return (FALSE);
         }
     }

     AddExt(pSrc, DefExt);            /* Adds the default extension if needed

     if (OpenFile(pSrc, (LPOFSTRUCT) &OfStruct, OF_EXIST) >= 0) {
         sprintf(str, "Replace existing %s?", pSrc);
         if (MessageBox(hWnd, str, "PrntFile",
                 MB_OKCANCEL | MB_ICONEXCLAMATION) == IDCANCEL)
             return (FALSE);
     }
     strcpy(pDest, pSrc);
     return (TRUE);
 }

 /****************************************************************************

     FUNCTION: SaveFile(HWND)

     PURPOSE: Save current file

     COMMENTS:

         This saves the current contents of the Edit buffer, and changes
         bChanges to indicate that the buffer has not been changed since the
         last save.

         Before the edit buffer is sent, you must get its handle and lock it
         to get its address.  Once the file is written, you must unlock the
         buffer.  This allows Windows to move the buffer when not in immediate
         use.

 ****************************************************************************/

 BOOL SaveFile(hWnd)
 HWND hWnd;
 {
     BOOL bSuccess;
     int IOStatus;                                  /* result of a file write

     if ((hFile = OpenFile(FileName, &OfStruct,
         OF_PROMPT | OF_CANCEL | OF_CREATE)) < 0) {

         /* If the file can't be saved */

         sprintf(str, "Cannot write to %s.", FileName);
         MessageBox(hWnd, str, NULL, MB_OK | MB_ICONHAND);
         return (FALSE);
     }


     hEditBuffer = SendMessage(hEditWnd, EM_GETHANDLE, 0, 0L);
     pEditBuffer = LocalLock(hEditBuffer);

     /* Set the cursor to an hourglass during the file transfer */

     hSaveCursor = SetCursor(hHourGlass);
     IOStatus = write(hFile, pEditBuffer, strlen(pEditBuffer));
     close(hFile);
     SetCursor(hSaveCursor);
     if (IOStatus != strlen(pEditBuffer)) {
         sprintf(str, "Error writing to %s.", FileName);
         MessageBox(hWnd, str,
             NULL, MB_OK | MB_ICONHAND);
         bSuccess = FALSE;
     }
     else {
         bSuccess = TRUE;                /* Indicates the file was saved
         bChanges = FALSE;               /* Indicates changes have been saved
     }

     LocalUnlock(hEditBuffer);
     return (bSuccess);
 }

 /****************************************************************************

     FUNCTION: QuerySaveFile(HWND);

     PURPOSE: Called when some action might lose current contents

     COMMENTS:

         This function is called whenever we are about to take an action that
         would lose the current contents of the edit buffer.

 ****************************************************************************/

 BOOL QuerySaveFile(hWnd)
 HWND hWnd;
 {
     int Response;
     FARPROC lpSaveAsDlg;

     if (bChanges) {
         sprintf(str, "Save current changes: %s", FileName);
         Response = MessageBox(hWnd, str,
             "PrntFile",  MB_YESNOCANCEL | MB_ICONHAND);
         if (Response == IDYES) {
 check_name:

             /* Make sure there is a filename to save to */

             if (!FileName[0]) {
                 lpSaveAsDlg = MakeProcInstance(SaveAsDlg, hInst);
                 Response = DialogBox(hInst, "SaveAs",
                     hWnd, lpSaveAsDlg);
                 FreeProcInstance(lpSaveAsDlg);
                 if (Response == IDOK)
                     goto check_name;
                 else
                     return (FALSE);
             }
             SaveFile(hWnd);
         }
         else if (Response == IDCANCEL)
             return (FALSE);
     }
     else
         return (TRUE);
 }

 /****************************************************************************

     FUNCTION: SetNewBuffer(HWND, HANDLE, PSTR)

     PURPOSE: Set new buffer for edit window

     COMMENTS:

         Point the edit window to the new buffer, update the window title, and
         redraw the edit window.  If hNewBuffer is NULL, then create an empty
         1K buffer, and return its handle.

 ****************************************************************************/

 void SetNewBuffer(hWnd, hNewBuffer, Title)
 HWND hWnd;
 HANDLE hNewBuffer;
 PSTR Title;
 {
     HANDLE hOldBuffer;

     hOldBuffer = SendMessage(hEditWnd, EM_GETHANDLE, 0, 0L);
     LocalFree(hOldBuffer);
     if (!hNewBuffer)                    /* Allocates a buffer if none exists
         hNewBuffer = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, 1);

     SendMessage(hEditWnd, EM_SETHANDLE, hNewBuffer, 0L); /* Updates the buffe
                   and displays new buffer */
     SetWindowText(hWnd, Title);
     SetFocus(hEditWnd);
     bChanges = FALSE;
 }


 /****************************************************************************

     FUNCTION: GetPrinterDC()

     PURPOSE:  Get hDc for current device on current output port according to
               info in WIN.INI.

     COMMENTS:

         Searches WIN.INI for information about what printer is connected, and
         if found, creates a DC for the printer.

         returns
             hDC > 0 if success
             hDC = 0 if failure

 ****************************************************************************/

 HANDLE GetPrinterDC()
 {
     char pPrintInfo[80];
     LPSTR lpTemp;
     LPSTR lpPrintType;
     LPSTR lpPrintDriver;
     LPSTR lpPrintPort;

     if (!GetProfileString("windows", "Device", (LPSTR)"", pPrintInfo, 80))
         return (NULL);
     lpTemp = lpPrintType = pPrintInfo;
     lpPrintDriver = lpPrintPort = 0;
     while (*lpTemp) {
         if (*lpTemp == ',') {
             *lpTemp++ = 0;
             while (*lpTemp == ' ')
                 lpTemp = AnsiNext(lpTemp);
             if (!lpPrintDriver)
                 lpPrintDriver = lpTemp;
             else {
                 lpPrintPort = lpTemp;
                 break;
             }
         }
         else
             lpTemp = AnsiNext(lpTemp);
     }

     return (CreateDC(lpPrintDriver, lpPrintType, lpPrintPort, (LPSTR) NULL));
 }

 /****************************************************************************

     FUNCTION: AbortProc()

     PURPOSE:  Processes messages for the Abort Dialog box

 ****************************************************************************/

 int FAR PASCAL AbortProc(hPr, Code)
 HDC hPr;                            /* for multiple printer display contexts
 int Code;                           /* printing status                */
 {
     MSG msg;

     /* Process messages intended for the abort dialog box */

     while (!bAbort && PeekMessage(&msg, NULL, NULL, NULL, TRUE))
         if (!IsDialogMessage(hAbortDlgWnd, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }

     /* bAbort is TRUE (return is FALSE) if the user has aborted */

     return (!bAbort);
 }

 /****************************************************************************

     FUNCTION: AbortDlg(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for printer abort dialog box

     MESSAGES:

         WM_INITDIALOG - initialize dialog box
         WM_COMMAND    - Input received

     COMMENTS

         This dialog box is created while the program is printing, and allows
         the user to cancel the printing process.

 ****************************************************************************/

 int FAR PASCAL AbortDlg(hDlg, msg, wParam, lParam)
 HWND hDlg;
 unsigned msg;
 WORD wParam;
 LONG lParam;
 {
     switch(msg) {

         /* Watch for Cancel button, RETURN key, ESCAPE key, or SPACE BAR */

         case WM_COMMAND:
             return (bAbort = TRUE);

         case WM_INITDIALOG:

             /* Set the focus to the Cancel box of the dialog */

             SetFocus(GetDlgItem(hDlg, IDCANCEL));
             SetDlgItemText(hDlg, IDC_FILENAME, FileName);
             return (TRUE);
         }
     return (FALSE);
 }


 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

         WM_INITDIALOG - initialize dialog box
         WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

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


 RAINBOW.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\RAINBOW\RAINBOW.C

 /*
  * RAINBOW -- Example Dialog Editor custom control
  *
  */

 #include <windows.h>
 #include <custcntl.h>
 #include "rainbow.h"

 /* global static variables */
 HANDLE    hLibData;
 HANDLE    hLibInstance;
 LPFNSTRTOID    lpfnVerId;
 LPFNIDTOSTR    lpfnIdStr;

 /* string for property lists */
 #define  IDFNLO          "lpfnIdFnLo"
 #define  IDFNHI          "lpfnIdFnHi"

 #define  RAINBOWCLASS      "Rainbow"

 /* general rainbow definitions */
 #define  ID              GetWindowWord( hWnd, GWW_ID )
 #define  PARENT          GetWindowWord( hWnd, GWW_HWNDPARENT )
 #define  INSTANCE          GetWindowWord( hWnd, GWW_HINSTANCE )

 /* rainbow specific definitions */
 #define  RAINBOW_EXTRA      12

 #define  RANGE            GetWindowWord( hWnd, 0 )
 #define  TABLE            GetWindowWord( hWnd, 2 )
 #define  WIDTH            GetWindowWord( hWnd, 4 )
 #define  HEIGHT          GetWindowWord( hWnd, 6 )
 #define  CHOICE          GetWindowWord( hWnd, 8 )
 #define  CAPTURE          GetWindowWord( hWnd, 10 )

 #define  SET_RANGE(x)      SetWindowWord( hWnd, 0, x )
 #define  SET_TABLE(x)      SetWindowWord( hWnd, 2, x )
 #define  SET_WIDTH(x)      SetWindowWord( hWnd, 4, x )
 #define  SET_HEIGHT(x)      SetWindowWord( hWnd, 6, x )
 #define  SET_CHOICE(x)      SetWindowWord( hWnd, 8, x )
 #define  SET_CAPTURE(x)      SetWindowWord( hWnd, 10, x )

 /* caret related definitions */
 #define  CARET_XPOS        ((CHOICE*WIDTH)+3)
 #define  CARET_YPOS        (3)
 #define  CARET_WIDTH        (WIDTH-6)
 #define  CARET_HEIGHT      (HEIGHT-6)

 /* selector related definitions */
 #define  SELECTOR_XPOS      ((CHOICE*WIDTH)+1)
 #define  SELECTOR_YPOS      (1)
 #define  SELECTOR_WIDTH      (WIDTH-2)
 #define  SELECTOR_HEIGHT    (HEIGHT-2)

 /* undocumented internal function definitions */
 int FAR PASCAL    lstrlen( LPSTR );
 int FAR PASCAL    lstrcmp( LPSTR, LPSTR );
 LPSTR FAR PASCAL  lstrcpy( LPSTR, LPSTR );
 LPSTR FAR PASCAL  lstrcat( LPSTR, LPSTR );

 /* internal rainbow function prototypes */
 BOOL FAR PASCAL   RainbowDlgFn( HWND, WORD, WORD, LONG );
 LONG FAR PASCAL   RainbowWndFn( HWND, WORD, WORD, LONG );
 void static      DrawSelector( HWND, HDC );

 /**/

 /*
  * LibMain( hInstance, wDataSegment, wHeapSize, lpszCmdLine ) : WORD
  *
  *    hInstance      library instance handle
  *    wDataSegment   library data segment
  *    wHeapSize      default heap size
  *    lpszCmdLine    command line arguments
  *
  * LibMain is called by LibEntry, which is called by Windows when
  * the DLL is loaded.  The LibEntry routine is provided
  * in the LIBENTRY.OBJ in the SDK Link Libraries disk.  (The source
  * LIBENTRY.ASM is also provided.)
  *
  * LibEntry initializes the DLL's heap, if a HEAPSIZE value is
  * specified in the DLL's DEF file.  Then LibEntry calls
  * LibMain.  The LibMain function below satisfies that call.
  *
  * LibMain performs all the initialization necessary to use the
  * rainbow user control.  Included in this initialization is the
  * registration of the Rainbow window class.
  *
 */

 int FAR PASCAL LibMain(
    HANDLE      hInstance,
    WORD        wDataSegment,
    WORD        wHeapSize,
    LPSTR       lpszCmdLine )
 {
   HANDLE      hClassStruct;
   LPWNDCLASS    lpClassStruct;

   /* register rainbow window if necessary */
   if ( hLibInstance == NULL ) {

     /* allocate memory for class structure */
     hClassStruct = GlobalAlloc( GHND, (DWORD)sizeof(WNDCLASS) );
     if ( hClassStruct ) {

       /* lock it down */
       lpClassStruct = (LPWNDCLASS)GlobalLock( hClassStruct );
       if ( lpClassStruct ) {

         /* define class attributes */
         lpClassStruct->lpszClassName =   (LPSTR)RAINBOWCLASS;
         lpClassStruct->hCursor =      LoadCursor( NULL, IDC_ARROW );
         lpClassStruct->lpszMenuName =    (LPSTR)NULL;
         lpClassStruct->style =        CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_GLO
         lpClassStruct->lpfnWndProc =    RainbowWndFn;
         lpClassStruct->hInstance =      hInstance;
         lpClassStruct->hIcon =        NULL;
         lpClassStruct->cbWndExtra =    RAINBOW_EXTRA;
         lpClassStruct->hbrBackground =  (HBRUSH)(COLOR_WINDOW + 1 );

         /* register rainbow window class */
         hLibInstance = ( RegisterClass(lpClassStruct) ) ? hInstance : NULL;

         /* unlock structure */
         GlobalUnlock( hClassStruct );

       }

       /* release class structure */
       GlobalFree( hClassStruct );

     }

   }

   /* return result 1 = success; 0 = fail */
   return( hLibInstance? 1:0 );
 }

 /**/


 /****************************************************************************
     FUNCTION:  WEP(int)

     PURPOSE:  Performs cleanup tasks when the DLL is unloaded.  WEP() is
               called automatically by Windows when the DLL is unloaded
               (no remaining tasks still have the DLL loaded).  It is
               strongly recommended that a DLL have a WEP() function,
               even if it does nothing but return, as in this example.

 *****************************************************************************
 VOID FAR PASCAL WEP (bSystemExit)
 int  bSystemExit;
 {
     return;
 }


 /*
  * RainbowInfo() : HANDLE
  *
  * This function returns a handle to a global block of memory that
  * contains various information about the kinds of controls the library
  * is capable of supporting.  This data block can, for example, be used
  * by the dialog editor when determining the capabilities of a particular
  * control library.
  *
  * Note that this handle becomes the property of the caller once this
  * function returns.  This implies that the caller must call GlobalFree
  * once it is finished with the data.
  *
  */

 HANDLE FAR PASCAL RainbowInfo()
 {
   HANDLE    hCtlInfo;
   LPCTLINFO  lpCtlInfo;

   /* allocate space for information structure */
   hCtlInfo = GlobalAlloc( GHND, (DWORD)sizeof(CTLINFO) );
   if ( hCtlInfo ) {

     /* attempt to lock it down */
     lpCtlInfo = (LPCTLINFO)GlobalLock( hCtlInfo );
     if ( lpCtlInfo ) {

       /* define the fixed portion of the structure */
       lpCtlInfo->wVersion = 100;
       lpCtlInfo->wCtlTypes = 1;
       lstrcpy( lpCtlInfo->szClass, RAINBOWCLASS );
       lstrcpy( lpCtlInfo->szTitle, "Sample User Control" );

       /* define the variable portion of the structure */
       lpCtlInfo->Type[0].wWidth = 33;
       lpCtlInfo->Type[0].wHeight = 20;
       lpCtlInfo->Type[0].dwStyle = WS_CHILD;
       lstrcpy( lpCtlInfo->Type[0].szDescr, "Rainbow" );

       /* unlock it */
       GlobalUnlock( hCtlInfo );

     } else {
       GlobalFree( hCtlInfo );
       hCtlInfo = NULL;
     }

   }

   /* return result */
   return( hCtlInfo );

 }

 /**/

 /*
  * RainbowStyle( hWnd, hCtlStyle, lpfnVeriyId, lpfnGetIdStr ) : BOOL;
  *
  *    hWnd           handle to parent window
  *    hCtlStyle      handle to control style
  *    lpfnVerifyId   pointer to the VerifyId function from Dialog editor
  *    lpfnGetIdStr   pointer to the GetIdStr functionn from Dialog editor
  *
  * This function enables the user to edit the style of a particular
  * control provided.  The current control style information is passed
  * in using a handle to a control style data structure.
  *
  * This function returns this same handle (referencing updated
  * information) if the dialog box is normally closed.  A value of
  * NULL is returned if the user cancelled the operation.
  *
  */

 BOOL FAR PASCAL RainbowStyle(
   HWND        hWnd,
   HANDLE      hCtlStyle,
   LPFNSTRTOID       lpfnVerifyId,
   LPFNIDTOSTR  lpfnGetIdStr )
 {
   FARPROC    lpDlgFn;
   HANDLE    hNewCtlStyle;

   /* initialization */
   hLibData = hCtlStyle;
   lpfnVerId = lpfnVerifyId;
   lpfnIdStr = lpfnGetIdStr;

   /* display dialog box */
   lpDlgFn = MakeProcInstance( (FARPROC)RainbowDlgFn, hLibInstance );
   hNewCtlStyle = ( DialogBox(hLibInstance,"RainbowStyle",hWnd,lpDlgFn) ) ? hL
   FreeProcInstance( lpDlgFn );

   /* return updated data block */
   return( hNewCtlStyle );

 }

 /**/

 /*
  * RainbowFlags( wFlags, lpszString, wMaxString ) : WORD;
  *
  *    wFlags         class style flags
  *    lpszString     class style string
  *    wMaxString     maximum size of class style string
  *
  * This function translates the class style flags provided into a
  * corresponding text string for output to an RC file.  The general
  * windows flags (contained in the low byte) are not interpreted,
  * only those in the high byte.
  *
  * The value returned by this function is the library instance
  * handle when sucessful, and NULL otherwise.
  *
  */

 WORD FAR PASCAL RainbowFlags(
   WORD        wFlags,
   LPSTR       lpszString,
   WORD        wMaxString )
 {
   lpszString[0] = NULL;
   return( 0 );
 }

 /**/

 /*
  * RainbowWndFn( hWnd, wMsg, wParam, lParam ) : LONG
  *
  *    hWnd          handle to rainbow window
  *    wMsg          message number
  *    wParam        single word parameter
  *    lParam        double word parameter
  *
  * This function is responsible for processing all the messages
  * which relate to the rainbow control window.  Note how the
  * code is written to avoid potential problems when re-entrancy
  * ocurrs - this involves the use of extra bytes associated with
  * the window data structure.
  *
  * The LONG value returned by this function is either a value
  * returned by the internal handling of the message or by the
  * default window procedure.
  *
  */

 LONG FAR PASCAL RainbowWndFn( hWnd, wMsg, wParam, lParam )
   HWND      hWnd;
   WORD      wMsg;
   WORD      wParam;
   LONG      lParam;
 {
   /* local variables */
   LONG      lResult;          /* temporary result variable */

   /* initialization */
   lResult = TRUE;

   /* process message */
   switch( wMsg )
     {
   case WM_GETDLGCODE : /* capture all key strokes */
     lParam = DLGC_WANTARROWS;
     break;
   case WM_CREATE : /* create pallette window */

     {
       /* temporary variables */
       HANDLE    hrgbList;        /* handle to rgb list */
       LONG FAR *  lprgbEntry;        /* pointer to rgb list */

       /* allocate space for rgb color list */
       hrgbList = GlobalAlloc( GMEM_MOVEABLE, sizeof(LONG)*16L );
       if ( hrgbList ) {

          /*
          * Define initial rgb color & value list - note that
          * eight default colors are selected with the values
          * matching each of the colors.
          */

         lprgbEntry = (LONG FAR *)GlobalLock( hrgbList );
         lprgbEntry[0] = RGB( 0x00, 0x00, 0x00 );
         lprgbEntry[1] = RGB( 0x00, 0x00, 0xFF );
         lprgbEntry[2] = RGB( 0x00, 0xFF, 0x00 );
         lprgbEntry[3] = RGB( 0xFF, 0x00, 0x00 );
         lprgbEntry[4] = RGB( 0x00, 0xFF, 0xFF );
         lprgbEntry[5] = RGB( 0xFF, 0xFF, 0x00 );
         lprgbEntry[6] = RGB( 0xFF, 0x00, 0xFF );
         lprgbEntry[7] = RGB( 0xFF, 0xFF, 0xFF );
         lprgbEntry[8] = RGB( 0x00, 0x00, 0x00 );
         lprgbEntry[9] = RGB( 0x00, 0x00, 0xFF );
         lprgbEntry[10] = RGB( 0x00, 0xFF, 0x00 );
         lprgbEntry[11] = RGB( 0xFF, 0x00, 0x00 );
         lprgbEntry[12] = RGB( 0x00, 0xFF, 0xFF );
         lprgbEntry[13] = RGB( 0xFF, 0xFF, 0x00 );
         lprgbEntry[14] = RGB( 0xFF, 0x00, 0xFF );
         lprgbEntry[15] = RGB( 0xFF, 0xFF, 0xFF );
         GlobalUnlock( hrgbList );

         /* define instance variables */
         SET_RANGE( 8 );
         SET_TABLE( hrgbList );
         SET_WIDTH( ((LPCREATESTRUCT)lParam)->cx / 8 );
         SET_HEIGHT( ((LPCREATESTRUCT)lParam)->cy );
         SET_CHOICE( 0 );
         SET_CAPTURE( FALSE );

       } else
         DestroyWindow( hWnd );

     }

     break;
   case WM_SIZE : /* window being resized */

     /* redefine width & height instance variables */
     SET_WIDTH( LOWORD(lParam) / 8 );
     SET_HEIGHT( HIWORD(lParam) );

     break;
   case WM_PAINT : /* paint control window */

     {
       PAINTSTRUCT    Ps;          /* paint structure */
       WORD        wEntry;        /* current color entry */
       HANDLE      hBrush;        /* handle to new brush */
       HANDLE      hOldBrush;      /* handle to old brush */
       LONG FAR *    lprgbEntry;      /* pointer to rgb list */

       /* start paint operation */
       BeginPaint( hWnd, (LPPAINTSTRUCT)&Ps );

       /* iteratively paint each color patch */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       for ( wEntry=0; wEntry<RANGE; wEntry++ ) {

         /* create solid brush for patch & select */
         hBrush = CreateSolidBrush( lprgbEntry[wEntry] );
         hOldBrush = SelectObject( Ps.hdc, hBrush );

         /* draw rectangle with brush fill */
         Rectangle(
           Ps.hdc,
           wEntry*WIDTH,
           0,
           (wEntry*WIDTH)+WIDTH,
           HEIGHT
         );

         /* unselect brush and delete */
         SelectObject( Ps.hdc, hOldBrush );
         DeleteObject( hBrush );

       }
       GlobalUnlock( TABLE );

       /* End paint operation */
       EndPaint( hWnd, (LPPAINTSTRUCT)&Ps );
     }

     break;
   case WM_KEYDOWN : /* key being pressed */

     {
       /* local variables */
       HDC        hDC;          /* display context handle */
       LONG FAR *    lprgbEntry;      /* pointer to rgb list */

       /* retrieve display context & unmark current selection */
       hDC = GetDC( hWnd );
       DrawSelector( hWnd, hDC );

       /* process virtual key codes */
       switch( wParam )
         {
       case VK_HOME : /* home key */
         SET_CHOICE( 0 );
         break;
       case VK_UP : /* up cursor key */
       case VK_LEFT : /* left cursor key */
         SET_CHOICE( (CHOICE > 0) ? CHOICE-1 : RANGE-1 );
         break;
       case VK_DOWN : /* down cursor key */
       case VK_RIGHT : /* right cursor key */
       case VK_SPACE : /* space bar - move right */
         SET_CHOICE( (CHOICE < RANGE-1) ? CHOICE+1 : 0 );
         break;
       case VK_END : /* end key */
         SET_CHOICE( RANGE-1 );
         break;
       default : /* some other key */
         lResult = FALSE;
         break;
       }

       /* mark new selection & release display context */
       DrawSelector( hWnd, hDC );
       ReleaseDC( hWnd, hDC );

       /* move caret to new position */
       SetCaretPos( CARET_XPOS, CARET_YPOS );

       /* notify parent of new selection */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       SendMessage(PARENT,WM_COMMAND,ID,lprgbEntry[RANGE+CHOICE]);
       GlobalUnlock( TABLE );

     }

     break;
   case WM_SETFOCUS : /* get focus - display caret */
     /* create caret & display */
     CreateCaret( hWnd, NULL, CARET_WIDTH, CARET_HEIGHT );
     SetCaretPos( CARET_XPOS, CARET_YPOS );
     ShowCaret( hWnd );
     break;

   case WM_LBUTTONDOWN : /* left button depressed - fall through */

     {
       /* local variables */
       HDC        hDC;          /* display context handle */
       LONG FAR *    lprgbEntry;      /* pointer to rgb list */

       /* retrieve display context */
       hDC = GetDC ( hWnd );

       /* unmark old selection & mark new one */
       DrawSelector( hWnd, hDC );
       SET_CHOICE( LOWORD(lParam)/WIDTH );
       DrawSelector( hWnd, hDC );

       /* release display context & move caret */
       ReleaseDC( hWnd, hDC );

       /* capture focus & move caret */
       SetFocus(hWnd);
       SetCaretPos( CARET_XPOS, CARET_YPOS );

       /* notify parent of new selection */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       SendMessage(PARENT,WM_COMMAND,ID,lprgbEntry[RANGE+CHOICE]);
       GlobalUnlock( TABLE );

       /* activate capture */
       SetCapture( hWnd );
       SET_CAPTURE( TRUE );

     }

     break;
   case WM_MOUSEMOVE : /* mouse being moved */

     /* track mouse only if capture on */
     if ( CAPTURE ) {

       /* local variables */
       HDC        hDC;          /* display context handle */
       WORD        wNewChoice;      /* new mouse selection */
       LONG FAR *    lprgbEntry;      /* pointer to rgb list */

       /* calculate new selection */
       wNewChoice = ( LOWORD(lParam) <= 0 ) ?
         0 :
         ( LOWORD(lParam)/WIDTH >= RANGE ) ?
           RANGE - 1 :
           LOWORD(lParam) / WIDTH;

       /* update display if different */
       if ( wNewChoice != CHOICE ) {

         /* retrieve display context */
         hDC = GetDC ( hWnd );

         /* unmark old selection & mark new one */
         DrawSelector( hWnd, hDC );
         SET_CHOICE( wNewChoice );
         DrawSelector( hWnd, hDC );

         /* release display context & move caret */
         ReleaseDC( hWnd, hDC );
         SetCaretPos( CARET_XPOS, CARET_YPOS );

         /* notify parent of new selection */
         lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
         SendMessage(PARENT,WM_COMMAND,ID,lprgbEntry[RANGE+CHOICE]);
         GlobalUnlock( TABLE );

       }

     }

     break;
   case WM_LBUTTONUP : /* left button released */

     /* release capture if active */
     if ( CAPTURE ) {
       SET_CAPTURE( FALSE );
       ReleaseCapture();
     }

     break;
   case WM_KILLFOCUS : /* kill focus - hide caret */
     DestroyCaret();
     break;
   case RM_SETSEL : /* select a color entry */
     {
       LONG FAR *    lprgbEntry;

       /* update selection & redraw rainbow */
       SET_CHOICE( (wParam >= RANGE) ? 0 : wParam );
       InvalidateRect( hWnd, NULL, TRUE );

       /* notify parent of change in color */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       SendMessage( PARENT, WM_COMMAND, ID, lprgbEntry[RANGE+CHOICE] );
       GlobalUnlock( TABLE );

       /* return new choice */
       lResult = CHOICE;

     }
     break;
   case RM_GETSEL : /* retrieve selected color */
     {
       LONG FAR *    lprgbEntry;

       /* return selected entry */
       lResult = CHOICE;

       /* define selected color */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       *(LONG FAR *)lParam = lprgbEntry[RANGE+CHOICE];
       GlobalUnlock( TABLE );

     }
     break;
   case RM_SETCOLORS : /* define rainbow color table */
     {
       WORD      wEntry;
       HANDLE    hrgbList;
       RECT      rectClient;
       LONG FAR *  lprgbEntry;

       /* release previous table from memory */
       GlobalFree( TABLE );

       hrgbList = GlobalAlloc(  GMEM_MOVEABLE,  sizeof(LONG)*wParam*2L);
       if ( hrgbList ) {

         /* define initial rgb colors & values */
         lprgbEntry = (LONG FAR *)GlobalLock( hrgbList );
         for ( wEntry=0; wEntry < wParam; wEntry++ ) {
           lprgbEntry[wEntry] = ((LONG FAR*)lParam)[wEntry];
           lprgbEntry[wParam+wEntry] = ((LONG FAR*)lParam)[wParam+wEntry];
         }
         GlobalUnlock( hrgbList );

         /* retrieve current window dimensions */
         GetClientRect( hWnd, &rectClient );

         /* re-define instance variables */
         SET_RANGE( wParam );
         SET_TABLE( hrgbList );
         SET_WIDTH( (rectClient.right-rectClient.left)/wParam );
         SET_HEIGHT( rectClient.bottom-rectClient.top );
         SET_CHOICE( 0 );

         /* update window & notify parent of new selection */
         InvalidateRect( hWnd, NULL, TRUE );
         SendMessage( PARENT, WM_COMMAND, ID, lprgbEntry[RANGE+CHOICE] );

         /* normal return */
         lResult = wParam;

       } else
         lResult = -1L;

     }
     break;
   case RM_GETCOLORS : /* retrieve rainbow color table */
     {
       WORD      wEntry;
       LONG FAR *  lprgbEntry;

       /* retrieve number of colors */
       lResult = RANGE;

       /* retrieve rgb color list */
       lprgbEntry = (LONG FAR *)GlobalLock( TABLE );
       for ( wEntry=0; (wEntry < RANGE)&&(wEntry < wParam); wEntry++ ) {
         ((LONG FAR *)lParam)[wEntry] = lprgbEntry[wEntry];
         ((LONG FAR *)lParam)[RANGE+wEntry] = lprgbEntry[RANGE+wEntry];
       }
       GlobalUnlock( TABLE );

     }
     break;
   case WM_DESTROY : /* window being destroyed */
     GlobalFree( TABLE );
     break;
   default : /* default window message processing */
     lResult = DefWindowProc( hWnd, wMsg, wParam, lParam );
     break;
   }

   /* return final result */
   return( lResult );

 }

 /**/

 /*
  * RainbowDlgFn( hDlg, wMessage, wParam, lParam ) : BOOL;
  *
  *    hDlg           dialog box handle
  *    wMessage       current window message
  *    wParam         word parameter
  *    lParam         long parameter
  *
  * This function is responsible for processing all the messages that
  * relate to the style dialog box.  This function transfers data
  * between itself and the RainbowStyle using a global data handle.
  *
  * If the user presses the OK button, this data handle is used to pass
  * back a new style data block.  It is left to the calling routine to
  * delete this new block.
  *
  */

 BOOL FAR PASCAL RainbowDlgFn(
   HWND        hDlg,
   WORD        wMessage,
   WORD        wParam,
   LONG        lParam )
 {
   BOOL      bResult;

   /* initialization */
   bResult = TRUE;

   /* process message */
   switch( wMessage )
     {
   case WM_INITDIALOG :
     {
       HANDLE    hCtlStyle;
       LPCTLSTYLE  lpCtlStyle;
       char      szId[  20 ];  /* temp. string to hold id */

       /* disable Ok button & save dialog data handle */
       hCtlStyle = hLibData;
       EnableWindow( GetDlgItem(hDlg,IDOK), FALSE );

       /* retrieve & display style parameters */
       if ( hCtlStyle ) {

         /* add handle to property list */
         SetProp( hDlg, MAKEINTRESOURCE(1), hCtlStyle );

         /* update dialog box fields */
         lpCtlStyle = (LPCTLSTYLE)GlobalLock( hCtlStyle );
         SetDlgItemText( hDlg, IDTEXT, lpCtlStyle->szTitle );

         /* Kanhom Ng 2/7/89
          * Set the id value string correctly.
          * Save the pointer to the verify id function from dialog editor
          */
         if ( lpfnIdStr )
         {
           (*lpfnIdStr)(lpCtlStyle->wId, (LPSTR)szId, sizeof( szId ) );
           SetDlgItemText( hDlg, IDVALUE, szId );
         }
         else
         {
           EnableWindow( GetDlgItem( hDlg, IDVALUE ), FALSE );
         }
         lstrcpy( lpCtlStyle->szClass, RAINBOWCLASS );
         SetProp( hDlg, IDFNHI, HIWORD( (DWORD)lpfnVerId ) );
         SetProp( hDlg, IDFNLO, LOWORD( (DWORD)lpfnVerId ) );

         GlobalUnlock( hCtlStyle );

       } else
         EndDialog( hDlg, FALSE );

     }
     break;
   case WM_COMMAND :

     /* process sub-message */
     switch( wParam )
       {
     case IDCANCEL : /* cancel dialog box */
       RemoveProp( hDlg, MAKEINTRESOURCE(1) );
       RemoveProp( hDlg, IDFNLO );
       RemoveProp( hDlg, IDFNHI );
       EndDialog( hDlg, FALSE );
       break;
     case IDOK : /* save dialog changes */
       {
         HANDLE    hCtlStyle;
         LPCTLSTYLE  lpCtlStyle;
         LPFNSTRTOID    lpfnId;      /* pointer to the verify id function from
         char      szId[ 20 ];    /* temp. string to hold the id */

         hCtlStyle = GetProp( hDlg, MAKEINTRESOURCE(1) );

         /* update structure contents */
         lpCtlStyle = (LPCTLSTYLE)GlobalLock( hCtlStyle );

         szId[ 0 ] = NULL;
         GetDlgItemText( hDlg, IDVALUE, szId, sizeof(szId) );
         lpfnId = (LPFNSTRTOID)MAKELONG( GetProp( hDlg, IDFNLO ), GetProp( hDl
         if ( lpfnId )
         {
           DWORD    dwResult; /* result ofthe verifyId function */

           dwResult = (*lpfnId)( (LPSTR)szId );
           if ( !(BOOL)dwResult )
           {
             /* Wrong id */
             GlobalUnlock( hCtlStyle );
             break;
           }

           lpCtlStyle->wId = HIWORD( dwResult );
         }

         GetDlgItemText( hDlg, IDTEXT, lpCtlStyle->szTitle, sizeof(lpCtlStyle-
         GlobalUnlock( hCtlStyle );

         RemoveProp( hDlg, MAKEINTRESOURCE(1) );
         RemoveProp( hDlg, IDFNLO );
         RemoveProp( hDlg, IDFNHI );

         /* end dialog box */
         hLibData = hCtlStyle;
         EndDialog( hDlg, TRUE );

       }
       break;
     case IDTEXT : /* control text */
     case IDVALUE : /* control id */

       /* enable or disable Ok button */
       if ( HIWORD(lParam) == EN_CHANGE )
         EnableWindow(
           GetDlgItem(hDlg,IDOK),
           (SendMessage(GetDlgItem(hDlg,IDTEXT),WM_GETTEXTLENGTH,0,0L) &&
            SendMessage(GetDlgItem(hDlg,IDVALUE),WM_GETTEXTLENGTH,0,0L)) ? TRU
         );

       break;
     default : /* something else */
       bResult = FALSE;
       break;
     }

     break;
   default :
     bResult = FALSE;
     break;
   }

   /* return final result */
   return( bResult );

 }

 /**/

 /*
  * DrawSelector( hWnd, hDC ) : void;
  *
  *    hWnd      window handle
  *    hDC      handle to display context
  *
  *  This function is responsible for drawing the selector
  * which surrounds the active color patch.  This drawing
  * process involves the use of the R2_NOT operator to
  * simplify the drawing & re-drawing process.
  *
  */

 void static DrawSelector( hWnd, hDC )
   HWND      hWnd;
   HDC      hDC;
 {
   /* local variables */
   HANDLE    hOldPen;          /* old pen */
   WORD      wOldROP2;        /* old raster op code */
   WORD      wOldBkMode;        /* old background mode */

   /* setup display context */
   wOldROP2 = SetROP2( hDC, R2_NOT );
   wOldBkMode = SetBkMode( hDC, TRANSPARENT );

   hOldPen = SelectObject( hDC, CreatePen(0,1,RGB(0,0,0)) );

   /* draw selector rectangle */
   Rectangle(
     hDC,
     SELECTOR_XPOS,
     SELECTOR_YPOS,
     SELECTOR_XPOS+SELECTOR_WIDTH,
     SELECTOR_YPOS+SELECTOR_HEIGHT
   );

   DeleteObject( SelectObject(hDC,hOldPen) );

   /* restore display context */
   SetBkMode( hDC, wOldBkMode );
   SetROP2( hDC, wOldROP2 );

 }


 SELECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SELECT\SELECT.C

 /****************************************************************************

     PROGRAM: Select.c

     PURPOSE: Contains library routines for selecting a region

     FUNCTIONS:

   StartSelection(HWND, POINT, LPRECT, int) - begin selection area
   UpdateSelection(HWND, POINT, LPRECT, int) - update selection area
   EndSelection(POINT, LPRECT) - end selection area
   ClearSelection(HWND, LPRECT, int) - clear selection area

 *****************************************************************************

 #include "windows.h"
 #include "select.h"

 /****************************************************************************
    FUNCTION: LibMain(HANDLE, WORD, WORD, LPSTR)

    PURPOSE:  Is called by LibEntry.  LibEntry is called by Windows when
              the DLL is loaded.  The LibEntry routine is provided in
              the LIBENTRY.OBJ in the SDK Link Libraries disk.  (The
              source LIBENTRY.ASM is also provided.)

              LibEntry initializes the DLL's heap, if a HEAPSIZE value is
              specified in the DLL's DEF file.  Then LibEntry calls
              LibMain.  The LibMain function below satisfies that call.

              The LibMain function should perform additional initialization
              tasks required by the DLL.  In this example, no initialization
              tasks are required.  LibMain should return a value of 1 if
              the initialization is successful.

 *****************************************************************************
 int FAR PASCAL LibMain(hModule, wDataSeg, cbHeapSize, lpszCmdLine)
 HANDLE  hModule;
 WORD    wDataSeg;
 WORD    cbHeapSize;
 LPSTR   lpszCmdLine;
 {
     return 1;
 }


 /****************************************************************************
     FUNCTION:  WEP(int)

     PURPOSE:  Performs cleanup tasks when the DLL is unloaded.  WEP() is
               called automatically by Windows when the DLL is unloaded (no
               remaining tasks still have the DLL loaded).  It is strongly
               recommended that a DLL have a WEP() function, even if it does
               nothing but returns success (1), as in this example.

 *****************************************************************************
 int FAR PASCAL WEP (bSystemExit)
 int  bSystemExit;
 {
     return(1);
 }


 /****************************************************************************

     FUNCTION: StartSelection(HWND, POINT, LPRECT, int)

     PURPOSE: Begin selection of region

 ****************************************************************************/

 int FAR PASCAL StartSelection(hWnd, ptCurrent, lpSelectRect, fFlags)
 HWND hWnd;
 POINT ptCurrent;
 LPRECT lpSelectRect;
 int fFlags;
 {
     if (lpSelectRect->left != lpSelectRect->right ||
       lpSelectRect->top != lpSelectRect->bottom)
   ClearSelection(hWnd, lpSelectRect, fFlags);

     lpSelectRect->right = ptCurrent.x;
     lpSelectRect->bottom = ptCurrent.y;

     /* If you are extending the box, then invert the current rectangle */

     if ((fFlags & SL_SPECIAL) == SL_EXTEND)
   ClearSelection(hWnd, lpSelectRect, fFlags);

     /* Otherwise, set origin to current location */

     else {
   lpSelectRect->left = ptCurrent.x;
   lpSelectRect->top = ptCurrent.y;
     }
     SetCapture(hWnd);
 }

 /****************************************************************************

     FUNCTION: UpdateSelection(HWND, POINT, LPRECT, int) - update selection ar

     PURPOSE: Update selection

 ****************************************************************************/

 int FAR PASCAL UpdateSelection(hWnd, ptCurrent, lpSelectRect, fFlags)
 HWND hWnd;
 POINT ptCurrent;
 LPRECT lpSelectRect;
 int fFlags;
 {
     HDC hDC;
     short OldROP;

     hDC = GetDC(hWnd);

     switch (fFlags & SL_TYPE) {

   case SL_BOX:
       OldROP = SetROP2(hDC, R2_NOTXORPEN);
       MoveTo(hDC, lpSelectRect->left, lpSelectRect->top);
       LineTo(hDC, lpSelectRect->right, lpSelectRect->top);
       LineTo(hDC, lpSelectRect->right, lpSelectRect->bottom);
       LineTo(hDC, lpSelectRect->left, lpSelectRect->bottom);
       LineTo(hDC, lpSelectRect->left, lpSelectRect->top);
       LineTo(hDC, ptCurrent.x, lpSelectRect->top);
       LineTo(hDC, ptCurrent.x, ptCurrent.y);
       LineTo(hDC, lpSelectRect->left, ptCurrent.y);
       LineTo(hDC, lpSelectRect->left, lpSelectRect->top);
       SetROP2(hDC, OldROP);
       break;

   case SL_BLOCK:
       PatBlt(hDC,
     lpSelectRect->left,
     lpSelectRect->bottom,
     lpSelectRect->right - lpSelectRect->left,
     ptCurrent.y - lpSelectRect->bottom,
     DSTINVERT);
       PatBlt(hDC,
     lpSelectRect->right,
     lpSelectRect->top,
     ptCurrent.x - lpSelectRect->right,
     ptCurrent.y - lpSelectRect->top,
     DSTINVERT);
       break;
     }
     lpSelectRect->right = ptCurrent.x;
     lpSelectRect->bottom = ptCurrent.y;
     ReleaseDC(hWnd, hDC);
 }

 /****************************************************************************

     FUNCTION: EndSelection(POINT, LPRECT)

     PURPOSE: End selection of region, release capture of mouse movement

 ****************************************************************************/

 int FAR PASCAL EndSelection(ptCurrent, lpSelectRect)
 POINT ptCurrent;
 LPRECT lpSelectRect;
 {
     lpSelectRect->right = ptCurrent.x;
     lpSelectRect->bottom = ptCurrent.y;
     ReleaseCapture();
 }

 /****************************************************************************

     FUNCTION: ClearSelection(HWND, LPRECT, int) - clear selection area

     PURPOSE: Clear the current selection

 ****************************************************************************/

 int FAR PASCAL ClearSelection(hWnd, lpSelectRect, fFlags)
 HWND hWnd;
 LPRECT lpSelectRect;
 int fFlags;
 {
     HDC hDC;
     short OldROP;

     hDC = GetDC(hWnd);
     switch (fFlags & SL_TYPE) {

   case SL_BOX:
       OldROP = SetROP2(hDC, R2_NOTXORPEN);
       MoveTo(hDC, lpSelectRect->left, lpSelectRect->top);
       LineTo(hDC, lpSelectRect->right, lpSelectRect->top);
       LineTo(hDC, lpSelectRect->right, lpSelectRect->bottom);
       LineTo(hDC, lpSelectRect->left, lpSelectRect->bottom);
       LineTo(hDC, lpSelectRect->left, lpSelectRect->top);
       SetROP2(hDC, OldROP);
       break;

   case SL_BLOCK:
       PatBlt(hDC,
     lpSelectRect->left,
     lpSelectRect->top,
     lpSelectRect->right - lpSelectRect->left,
     lpSelectRect->bottom - lpSelectRect->top,
     DSTINVERT);
       break;
     }
     ReleaseDC(hWnd, hDC);
 }


 SERVDATA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\SERVDATA.C

 /****************************************************************************

     MODULE: SERVDATA.C

     PURPOSE: Maintains conversation information.


 ****************************************************************************/

 #include "windows.h"

 #include "dde.h"
 #include "server.h"
 #include <string.h>

 typedef struct CONV
 {
     HWND hwndServerDDE;
     HWND hwndClientDDE;
     BOOL bInClientRequestedTerminate;
 };

 typedef struct ADVISE
 {
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     int         nItem;
     ATOM        atomItem;
     BOOL        bAckRequest;
     BOOL        bDeferUpdate;
     BOOL        bAwaitingAck;
     HANDLE      hData;
 };

 struct CONV Conv[CONV_MAX_COUNT];
 static int nConvCount = 0;
 static struct ADVISE Advise[ADVISE_MAX_COUNT];
 static int nAdviseCount = 0;

 struct ADVISE * NEAR FindAdvise(HWND, int);
 struct CONV *  NEAR FindConv(HWND);


 /****************************************************************************

     FUNCTION: AddAdvise

     PURPOSE:  Register a new hot or warm link to a specified client, for
         a specified server application item (1, 2, or 3).

 ****************************************************************************/
 BOOL AddAdvise(hwndServerDDE, hDDEAdviseOptions, atomItem, nItem)
     HWND   hwndServerDDE;
     HANDLE hDDEAdviseOptions;
     ATOM   atomItem;
     int    nItem;
 {
     struct ADVISE     * pAdvise;
     DDEADVISE FAR     * lpDDEAdviseOptions;
     int     nAdviseIndex;

     if (nAdviseCount >= ADVISE_MAX_COUNT)
     {
   MessageBox(hwndMain,
             "Maximum advisories exceeded",
             "Server",
             MB_ICONEXCLAMATION | MB_OK);
         return (FALSE);
     }
     if ((lpDDEAdviseOptions
           = (DDEADVISE FAR *)GlobalLock(hDDEAdviseOptions)) == NULL)
         return (FALSE);

     for (pAdvise = Advise, nAdviseIndex = 0;
    nAdviseIndex < nAdviseCount;
    pAdvise++, nAdviseIndex++)
     {
   if (pAdvise->hwndServerDDE == hwndServerDDE
       && pAdvise->nItem == nItem)
   {
       MessageBox(hwndMain,
     "Advisory (paste link) already established",
     "Server",
     MB_ICONEXCLAMATION | MB_OK);
       GlobalUnlock(hDDEAdviseOptions);
       return (FALSE);
   }
     }

     pAdvise = Advise + nAdviseCount++;

     pAdvise->hwndServerDDE = hwndServerDDE;
     pAdvise->hwndClientDDE = GetHwndClientDDE(hwndServerDDE);
     pAdvise->nItem = nItem;
     pAdvise->atomItem = atomItem;
     pAdvise->bAckRequest = lpDDEAdviseOptions->fAckReq;
     pAdvise->bDeferUpdate = lpDDEAdviseOptions->fDeferUpd;
     pAdvise->bAwaitingAck = FALSE;

     GlobalUnlock(hDDEAdviseOptions);
     return (TRUE);
 }



 /****************************************************************************

     FUNCTION: AddConv

     PURPOSE:  Register a new conversation with a client window

 ****************************************************************************/
 BOOL AddConv(hwndServerDDE, hwndClientDDE)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
 {
     struct CONV * pConv;

     if (nConvCount >= CONV_MAX_COUNT)
     {
         return (FALSE);
     }

     if (FindConv(hwndServerDDE) != NULL)
     {
   return (FALSE); /* conversation already added */
     }

     pConv = Conv + nConvCount++;
     pConv->hwndServerDDE = hwndServerDDE;
     pConv->hwndClientDDE = hwndClientDDE;
     pConv->bInClientRequestedTerminate = FALSE;
     return (TRUE);
 }



 /***********************************************************************

     FUNCTION:  AtLeastOneConvActive

     PURPOSE:   Used during termination of application, to
          determine whether any conversations are still active
          while the conversations are being terminated.

 ***********************************************************************/
 BOOL AtLeastOneConvActive()
 {
     return (nConvCount? TRUE: FALSE);
 }



 /****************************************************************************

     FUNCTION: CheckOutSentData

     PURPOSE:  Set Awaiting Ack state to true for specified item.

 ****************************************************************************/
 void CheckOutSentData(hwndServerDDE, nItem, atomItem, hData)
     HWND    hwndServerDDE;
     int     nItem;
     ATOM    atomItem;
     HANDLE  hData;
 {
     struct ADVISE * pAdvise;

     if (!(pAdvise = FindAdvise(hwndServerDDE, nItem)))
         return;
     pAdvise->bAwaitingAck = TRUE;
     pAdvise->atomItem = atomItem;
     pAdvise->hData = hData;
     return;
 }



 /****************************************************************************

     FUNCTION: DoEditCopy

     PURPOSE:  Copy selected data to clipboard in two formats:
         CF_TEXT and (registered) "Link" format.

 ****************************************************************************/
 void DoEditCopy(nItem)
     int   nItem;
 {

     /* Format string and set clipboard data here */
     HANDLE  hTextData;
     HANDLE  hConvData;
     char  szItemValue[ITEM_VALUE_MAX_SIZE+1];
     LPSTR  lpTextData, lpConvData;

     if (!GetDlgItemText(hwndMain, nItem, szItemValue, ITEM_VALUE_MAX_SIZE))
   strcpy(szItemValue, " ");

     /* Copy item value in CF_TEXT format to global memory object */

     if (!(hTextData
     = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, (DWORD)lstrlen(szItemValue)+1))
   return;
     if (!(lpTextData = GlobalLock(hTextData)))
     {
   GlobalFree(hTextData);
   return;
     }
     lstrcpy(lpTextData, szItemValue);
     GlobalUnlock(hTextData);

     /* Copy item value in "Link" format to global memory object */

     if (!(hConvData
     = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
       (DWORD)APP_MAX_SIZE+TOPIC_MAX_SIZE+ITEM_NAME_MAX_SIZE+4)))
        return;
     if (!(lpConvData = GlobalLock(hConvData)))
     {
        GlobalFree(hConvData);
        return;
     }

     /* Compose paste link string, each sub-string is null terminated */
     /* Format is <app> <null> <topic> <null> <item> <null> <null>    */
     lstrcpy(lpConvData, "Server");
     lpConvData = lpConvData + lstrlen(lpConvData) + 1;  /* '+1' adds null */
     lstrcpy(lpConvData, szDocName);   /* topic */
     lpConvData += (lstrlen(lpConvData) + 1);
     lstrcpy(lpConvData, "item#");
     lpConvData[4] = '1' + nItem - 1;
     *(lpConvData + lstrlen(lpConvData) + 1) = 0;  /* final null */

     GlobalUnlock(hConvData);

     if (OpenClipboard(hwndMain))
     {
        EmptyClipboard();

        SetClipboardData(CF_TEXT, hTextData);
        SetClipboardData(cfLink, hConvData);

        CloseClipboard();
     }
     else
     {
        GlobalFree(hTextData);
        GlobalFree(hConvData);
     }

     return;
 }



 /****************************************************************************

     FUNCTION: FindAdvise

     PURPOSE:  Find advisory data for a specific conversation item.

 ****************************************************************************/
 struct ADVISE * NEAR FindAdvise(hwndServerDDE, nItem)
     HWND hwndServerDDE;
     int  nItem;
 {
     struct ADVISE * pAdvise;
     int             nAdviseIndex;

     for (nAdviseIndex = 0, pAdvise = Advise;
          nAdviseIndex < nAdviseCount;
          nAdviseIndex++, pAdvise++)
     {
   if (pAdvise->hwndServerDDE == hwndServerDDE
             && pAdvise->nItem == nItem)
         {
             return (pAdvise);
         }
     }
     return (NULL);
 }





 /****************************************************************************

     FUNCTION: FindConv

     PURPOSE:  Find the conversation for a specified server DDE window.

 ****************************************************************************/
 struct CONV * NEAR FindConv(hwndServerDDE)
     HWND  hwndServerDDE;
 {
     struct CONV * pConv;
     int     nConvIndex;

     for (nConvIndex = 0, pConv = Conv;
    nConvIndex < nConvCount;
    nConvIndex++, pConv++)
     {
   if (pConv->hwndServerDDE == hwndServerDDE)
       return (pConv);
     }
     return (NULL);
 }



 /****************************************************************************

     FUNCTION: GetAdviseData

     PURPOSE:  Get advisory data for a specified conversation item.

 ****************************************************************************/
 BOOL GetAdviseData(hwndServerDDE, nItem, szItemName, szItemValue,
                    pbDeferUpdate, pbAckRequest)
     HWND   hwndServerDDE;
     int    nItem;
     char * szItemName;
     char * szItemValue;
     BOOL * pbDeferUpdate;
     BOOL * pbAckRequest;
 {
     struct ADVISE * pAdvise;

     if (!(pAdvise = FindAdvise(hwndServerDDE, nItem)))
         return (FALSE);
     strcpy(szItemName, "Item#");
     szItemName[4] = pAdvise->nItem==1? '1': pAdvise->nItem==2? '2': '3';
     *pbDeferUpdate = pAdvise->bDeferUpdate;
     *pbAckRequest = pAdvise->bAckRequest;
     if (!GetDlgItemText(hwndMain, nItem, szItemValue, ITEM_VALUE_MAX_SIZE))
         strcpy(szItemValue," ");

     return (TRUE);
 }



 /****************************************************************************

     FUNCTION: GetHwndClientDDE

     PURPOSE:  Get the hwnd of the client in conversation with a specified
         server DDE window.

 ****************************************************************************/
 HWND GetHwndClientDDE(hwndServerDDE)
     HWND  hwndServerDDE;
 {
     struct CONV * pConv;

     if (!(pConv = FindConv(hwndServerDDE)))
   return (NULL);
     return (pConv->hwndClientDDE);
 }



 /****************************************************************************

     FUNCTION: GetNextAdvise

     PURPOSE:  Find a client that needs to be notified that a value of
         a specified item (a hot or warm link item) has changed.
         Since a hot or warm link to the item may have been established
         for multiple conversations (multiple clients), this function
         is set up to step through the list of such conversations.
         Start the list by passing a NULL hwndClientDDE.  To get the
         next conversation in the list, pass the previous client returned
         by this function.

 ****************************************************************************/
 HWND GetNextAdvise(hwndServerDDE, nItem)
     HWND hwndServerDDE;
     int  nItem;
 {
     struct ADVISE * pAdvise;
     int             nAdviseIndex;

     if (hwndServerDDE)
     {
         for (nAdviseIndex = 0, pAdvise = Advise;
              nAdviseIndex < nAdviseCount;
              nAdviseIndex++, pAdvise++)
         {
       if (pAdvise->hwndServerDDE == hwndServerDDE
                 && pAdvise->nItem == nItem)
             {
                 pAdvise++;
                 break;
             }
         }
         if (nAdviseIndex >= nAdviseCount)
             return (NULL);
     }
     else
     {
         pAdvise = Advise;
         nAdviseIndex = 0;
     }
     for ( ; nAdviseIndex < nAdviseCount; nAdviseIndex++, pAdvise++)
     {
         if (pAdvise->nItem == nItem)
         {
       return (pAdvise->hwndServerDDE);
         }
     }
     return (NULL);
 }



 /****************************************************************************

     FUNCTION: GetNextConv

     PURPOSE:  Get next client in list of conversations.  To get the
         first hwndServerDDE in the conversation list, pass in a NULL
         value for hwndServerDDE.

 ****************************************************************************/
 HWND GetNextConv(hwndServerDDE)
     HWND hwndServerDDE;
 {
     struct CONV * pConv;
     int     nConvIndex;

     if (hwndServerDDE)
     {
   for (nConvIndex = 0, pConv = Conv;
        nConvIndex < nConvCount;
        nConvIndex++, pConv++)
         {
       if (pConv->hwndServerDDE == hwndServerDDE)
             {
     if (++nConvIndex < nConvCount)
         return (++pConv)->hwndServerDDE;
                 else
                     return (NULL);
             }
         }
         return (NULL);
     }
     if (nConvCount > 0)
   return (Conv[0].hwndServerDDE);
     else
         return (NULL);
 }



 /****************************************************************************

     FUNCTION: GlobalFreeSentData

     PURPOSE:  A global memory object (hData) was sent in a WM_DDE_DATA
         message, but the client never used it.  So, the server is
         responsible for freeing the object.

 ****************************************************************************/
 void GlobalFreeSentData(hwndServerDDE, nItem)
     HWND  hwndServerDDE;
     int   nItem;
 {
     struct ADVISE * pAdvise;

     if (!(pAdvise = FindAdvise(hwndServerDDE, nItem)))
         return;
     pAdvise->bAwaitingAck = FALSE;
     GlobalDeleteAtom(pAdvise->atomItem);
     GlobalFree(pAdvise->hData);
     return;
 }



 /****************************************************************************

     FUNCTION: IsConvInTerminateState

     PURPOSE:  Terminate whether conversation with specified client is
         in process of being terminated.

 ****************************************************************************/
 BOOL IsConvInTerminateState(hwndServerDDE)
     HWND  hwndServerDDE;
 {
     struct CONV * pConv;

     if (pConv = FindConv(hwndServerDDE))
   return (pConv->bInClientRequestedTerminate);
     else
         return (FALSE);
 }


 /****************************************************************************

     FUNCTION: RemoveAdvise

     PURPOSE:  Cancel a hot or warm link for a specified conversation item.
         If a 0 value is specified for nItem, then all hot/warm links
               for the specified client are removed.

 ****************************************************************************/
 BOOL RemoveAdvise(hwndServerDDE, nItem)
     HWND  hwndServerDDE;
     int   nItem;
 {
     struct ADVISE * pAdvise;
     int             nAdviseIndex;
     int             nRemoveCount;

     nRemoveCount = 0;
     for (nAdviseIndex = 0, pAdvise = Advise;
          nAdviseIndex < nAdviseCount;
          nAdviseIndex++, pAdvise++)
     {
         if (nRemoveCount)
         {
             *(pAdvise-nRemoveCount) = *pAdvise;
         }
   if (pAdvise->hwndServerDDE == hwndServerDDE
             && (!nItem || pAdvise->nItem == nItem))
         {
             nRemoveCount++;
         }

     }
     if (nRemoveCount)
     {
         nAdviseCount -= nRemoveCount;
         return (TRUE);
     }
     else
     {
         return (FALSE);
     }
 }



 /****************************************************************************

     FUNCTION: RemoveConv

     PURPOSE:  Remove conversation from conversation list, and remove
         all hot/warm links associated with that conversation
         from the advisory list.

 ****************************************************************************/
 void RemoveConv(hwndServerDDE)
     HWND hwndServerDDE;
 {
     struct CONV   * pConv;
     int       nConvIndex;
     struct ADVISE * pAdvise;
     struct ADVISE * pAdviseShift;
     int             nAdviseIndex;
     int             nAdviseDecrement;

     for (nConvIndex = 0, pConv = Conv;
    nConvIndex < nConvCount;
    nConvIndex++, pConv++)
     {
   if (pConv->hwndServerDDE == hwndServerDDE)
             break;
     }
     nConvCount--;
     while (nConvIndex < nConvCount)
     {
   *pConv = *(pConv+1);
   nConvIndex++;
   pConv++;
     }

     /* Remove each hot/warm link */

     pAdviseShift = Advise;
     nAdviseDecrement = 0;
     for (nAdviseIndex = 0, pAdvise = Advise;
          nAdviseIndex < nAdviseCount;
          nAdviseIndex++, pAdvise++)
     {
   if (pAdvise->hwndServerDDE == hwndServerDDE)
         {
             nAdviseDecrement++;
             if (pAdvise->bAwaitingAck)
             { /* Destroy objects perhaps not destroyed by client */
     GlobalDeleteAtom(pAdvise->atomItem);
                 GlobalFree(pAdvise->hData);
             }
         }
         else
         {
             *(pAdviseShift++) = *pAdvise;
         }
     }
     nAdviseCount -= nAdviseDecrement;
     return;
 }



 /****************************************************************************

     FUNCTION: SetConvInTerminateState

     PURPOSE:  Set conversations's terminate state to TRUE.

 ****************************************************************************/
 void SetConvInTerminateState(hwndServerDDE)
     HWND  hwndServerDDE;
 {
     struct CONV * pConv;

     if (pConv = FindConv(hwndServerDDE))
   pConv->bInClientRequestedTerminate = TRUE;
     return;
 }


 SERVDDE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\SERVDDE.C

 /****************************************************************************

     MODULE: SERVDDE.C

     PURPOSE: Processes incoming and outgoing DDE messages


 ****************************************************************************/

 #include "windows.h"

 #include "dde.h"
 #include "server.h"
 #include <string.h>

 #define DEFAULT_ACK_TIME_OUT_MILLISEC 10000
 static int nAckTimeOut;

 static BOOL   bTerminating = FALSE;

 int  NEAR GetDocIndexGivenName(char*);
 int  NEAR GetItemNumber(char*);




 /****************************************************************************

     FUNCTION: DDEWndProc

     PURPOSE:  Handles all DDE messages received by the server application.

 ****************************************************************************/
 long FAR PASCAL DDEWndProc(hwnd, message, wParam, lParam)
     HWND      hwnd;
     unsigned  message;
     WORD      wParam;
     LONG      lParam;
 {
     switch (message)
     {

         case WM_DDE_ACK:
             ServerAcknowledge(hwnd, (HWND)wParam, lParam);
       return (0L);

   case WM_TIMER:   /* time out on waiting for ACK in response */
        /* to WM_DDE_DATA sent by this server      */

       ServerAcknowledge(hwnd, (HWND)wParam, 0L); /* simulates NACK */
       return (0L);

         case WM_DDE_ADVISE:
             ServerAdvise(hwnd, (HWND)wParam, lParam);
       return (0L);

         case WM_DDE_POKE:
             ServerPoke(hwnd, (HWND)wParam, lParam);
       return (0L);

         case WM_DDE_TERMINATE:
             ServerTerminate(hwnd, (HWND)wParam);
       return (0L);

         case WM_DDE_UNADVISE:
             ServerUnadvise(hwnd, (HWND)wParam, lParam);
       return (0L);

         case WM_DDE_REQUEST:
             ServerRequest(hwnd, (HWND)wParam, lParam);
       return (0L);

   case WM_DDE_EXECUTE:
       ServerExecute(hwnd, (HWND)wParam, (HANDLE)HIWORD(lParam));
       return (0L);

   default:
         return (DefWindowProc(hwnd, message, wParam, lParam));
     }
 }



 /****************************************************************************

     FUNCTION: GetItemNumber

     PURPOSE:  Get server control i.d. (1, 2, or 3) given item name.

 ****************************************************************************/
 int NEAR GetItemNumber(szItem)
     char * szItem;
 {
     int nItem;

     if (!strcmpi(szItem, "ITEM1"))
         nItem = 1;
     else if (!strcmpi(szItem, "ITEM2"))
         nItem = 2;
     else if (!strcmpi(szItem, "ITEM3"))
         nItem = 3;
     else
         nItem = 0;
     return (nItem);
 }



 /****************************************************************************

     FUNCTION: InitAckTimeOut

     PURPOSE:  Get DDE timeout value from win.ini.  Value is in milliseconds.

 ****************************************************************************/
 void InitAckTimeOut(void)
 {

    /* Finds value in win.ini section corresponding to application name */

    nAckTimeOut = GetPrivateProfileInt("Server",
              "DdeTimeOut",
              DEFAULT_ACK_TIME_OUT_MILLISEC,
                                "server.ini");
    return;
 }



 /****************************************************************************

     FUNCTION: SendData

     PURPOSE:  Send data to client.

 ****************************************************************************/
 void SendData(hwndServerDDE, hwndClientDDE, szItemName, szItemValue,
                    bDeferUpdate, bAckRequest)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     char * szItemName;
     char * szItemValue;
     BOOL   bDeferUpdate;
     BOOL   bAckRequest;
 {
     ATOM          atomItem;
     HANDLE        hData;
     DDEDATA FAR * lpData;
     int           nItem;

     if (bDeferUpdate)
     {
         atomItem = GlobalAddAtom((LPSTR)szItemName);
   /* notify client with null data since advise was set up for */
   /* deferred update              */
   if (!PostMessage(hwndClientDDE,
                 WM_DDE_DATA,
     hwndServerDDE,
     MAKELONG(0, atomItem)))
         {
             GlobalDeleteAtom(atomItem);
         }
         return;
     }

     /* Allocate size of DDE data header, plus the data:  a string,  */
     /* <CR> <LR> <NULL>.  The byte for the string null terminator */
     /* is counted by DDEDATA.Value[1].           */

     if (!(hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
             (LONG)sizeof(DDEDATA) +lstrlen(szItemValue) + 2)))
         return;
     if (!(lpData = (DDEDATA FAR*)GlobalLock(hData)))
     {
   GlobalFree(hData);
         return;
     }

     lpData->fAckReq = bAckRequest;
     lpData->cfFormat = CF_TEXT;
     lstrcpy((LPSTR)lpData->Value, (LPSTR)szItemValue);
     /* each line of CF_TEXT data is terminated by CR/LF */
     lstrcat((LPSTR)lpData->Value, (LPSTR)"\r\n");
     GlobalUnlock(hData);
     atomItem = GlobalAddAtom((LPSTR)szItemName);
     if (!PostMessage(hwndClientDDE,
             WM_DDE_DATA,
       hwndServerDDE,
             MAKELONG(hData, atomItem)))
     {
         GlobalFree(hData);
         GlobalDeleteAtom(atomItem);
   return;
     }
     if (bAckRequest)
     {
   SetTimer(hwndServerDDE, hwndClientDDE, nAckTimeOut, NULL);
   nItem = GetItemNumber(szItemName);
   /* hData is to be deleted if not read by client for some reason */
   CheckOutSentData(hwndServerDDE, nItem, atomItem, hData);
     }
     return;
 }



 /****************************************************************************

     FUNCTION: SendTerminate

     PURPOSE:  Post terminate message and indicate that conversation is
         in process ot being terminated.

 ****************************************************************************/
 void SendTerminate(hwndServerDDE, hwndClientDDE)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
 {
     SetConvInTerminateState(hwndServerDDE);
     PostMessage(hwndClientDDE, WM_DDE_TERMINATE, hwndServerDDE, 0L);
     return;
 }



 /****************************************************************************

     FUNCTION: ServerAcknowledge

     PURPOSE:  Called when server application receives ACK or NACK, or
         when server receives time out waiting for response to
         WM_DDE_DATA.

 ****************************************************************************/
 void ServerAcknowledge(hwndServerDDE, hwndClientDDE, lParam)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     char szItemName[ITEM_NAME_MAX_SIZE+1];
     int  nItem;

     KillTimer(hwndServerDDE, hwndClientDDE);

     if (!(LOWORD(lParam) & 0x8000))
     {
         GlobalGetAtomName(HIWORD(lParam), szItemName, ITEM_NAME_MAX_SIZE);
         nItem = GetItemNumber(szItemName);
   GlobalFreeSentData(hwndServerDDE, nItem);
   MessageBox(hwndMain,
             "DDE send data failed",
             "Server",
             MB_ICONEXCLAMATION | MB_OK);
     }
     if (HIWORD(lParam))    /* 0 if time-out, so don't try to delete */
   GlobalDeleteAtom(HIWORD(lParam));
     return;
 }



 /****************************************************************************

     FUNCTION: ServerAdvise

     PURPOSE:  Called when server application receives WM_DDE_ADVISE message.

 ****************************************************************************/
 void ServerAdvise(hwndServerDDE, hwndClientDDE, lParam)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     HANDLE          hDDEAdviseOptions;
     DDEADVISE FAR * lpDDEAdviseOptions;
     ATOM            atomItem;
     char            szItem[ITEM_NAME_MAX_SIZE+1];
     int             nItem;

     hDDEAdviseOptions = LOWORD(lParam);
     atomItem = HIWORD(lParam);

     GlobalGetAtomName(atomItem, szItem, ITEM_NAME_MAX_SIZE);

     if (!(nItem = GetItemNumber(szItem))
   || !AddAdvise(hwndServerDDE, hDDEAdviseOptions, atomItem, nItem))
     {
   PostMessage(hwndClientDDE,
             WM_DDE_ACK,
       hwndServerDDE,
             MAKELONG(0, atomItem)); /* negative acknowledgement */
         return;
     }
     PostMessage(hwndClientDDE,
         WM_DDE_ACK,
   hwndServerDDE,
         MAKELONG(0x8000, atomItem)); /* positive acknowledgement */
     return;
 }



 /****************************************************************************

     FUNCTION: ServerExecute

     PURPOSE:  Called when server application receives WM_DDE_EXECUTE message.

 ****************************************************************************/
 void ServerExecute(hwndServerDDE, hwndClientDDE, hCommand)
     HWND    hwndServerDDE;
     HWND    hwndClientDDE;
     HANDLE  hCommand;
 {
     LPSTR   lpstrCommand;
     char    szExecuteString[EXECUTE_STRING_MAX_SIZE+1];

     if (!(lpstrCommand = GlobalLock(hCommand)))
     {
   PostMessage(hwndClientDDE,
             WM_DDE_ACK,
       hwndServerDDE,
       MAKELONG(0, hCommand)); /* negative acknowledgement */
         return;
     }
     if (lstrlen(lpstrCommand) > EXECUTE_STRING_MAX_SIZE)
   lpstrCommand[EXECUTE_STRING_MAX_SIZE] = 0;
     lstrcpy(szExecuteString, lpstrCommand);
     GlobalUnlock(hCommand);
     PostMessage(hwndClientDDE,
   WM_DDE_ACK,
   hwndServerDDE,
   MAKELONG(0x8000, hCommand)); /* positive acknowledgement */

     MessageBox(hwndMain,
   szExecuteString,
   "Server Received Execute Command",
   MB_OK);
     return;
 }




 /****************************************************************************

     FUNCTION: ServerInitiate

     PURPOSE:  Called when server application receives WM_DDE_INITIATE message

 ****************************************************************************/
 void ServerInitiate(hwndClientDDE, lParam)
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     HWND  hwndServerDDE;
     ATOM  atomApplicationRcvd;
     ATOM  atomTopicRcvd;
     ATOM  atomApplicationReturn;
     ATOM  atomTopicReturn;
     char  szApplication[APP_MAX_SIZE+1];
     char  szTopic[TOPIC_MAX_SIZE+1];

     if (!(hwndServerDDE = CreateWindow(
       "ServerDDEWndClass",
       "ServerDDE",
       WS_CHILD,  /* not visible */
       0, 0, 0, 0, /* no position or dimensions */
       hwndMain,  /* parent */
       NULL,  /* no menu */
       hInst,
       NULL)))
     {
   return;
     }

     if (atomApplicationRcvd = LOWORD(lParam))
         GlobalGetAtomName(atomApplicationRcvd, szApplication, APP_MAX_SIZE);
     if (atomApplicationRcvd && strcmpi(szApplication,"SERVER"))
     { /* if application was specified but it wasn't "server" */
         return;
     }
     if (atomTopicRcvd = HIWORD(lParam))
     {
         GlobalGetAtomName(atomTopicRcvd, szTopic, TOPIC_MAX_SIZE);
         if (strcmpi(szTopic, szDocName))
             return;
     }
     if (AddConv(hwndServerDDE, hwndClientDDE))
     {
         atomApplicationReturn = GlobalAddAtom("SERVER");
         atomTopicReturn = GlobalAddAtom(szDocName);
   if (!SendMessage(hwndClientDDE,
                 WM_DDE_ACK,
     hwndServerDDE,
                 MAKELONG(atomApplicationReturn, atomTopicReturn)))
         {
             GlobalDeleteAtom(atomApplicationReturn);
             GlobalDeleteAtom(atomTopicReturn);
         }
     }
     return;
 }



 /****************************************************************************

     FUNCTION: ServerPoke

     PURPOSE:  Called when server application receives WM_DDE_POKE message.

 ****************************************************************************/
 void ServerPoke(hwndServerDDE, hwndClientDDE, lParam)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     HANDLE        hPokeData;
     DDEPOKE FAR * lpPokeData;
     ATOM          atomItem;
     int           nItem;
     char          szItemName[ITEM_NAME_MAX_SIZE+1];
     char          szItemValue[ITEM_VALUE_MAX_SIZE+1];
     BOOL          bRelease;
     char        * pcCarriageReturn;


     hPokeData = LOWORD(lParam);
     atomItem = HIWORD(lParam);

     GlobalGetAtomName(atomItem, szItemName, ITEM_NAME_MAX_SIZE);
     if (!(lpPokeData = (DDEPOKE FAR *)GlobalLock(hPokeData))
         || lpPokeData->cfFormat != CF_TEXT
         || !(nItem = GetItemNumber(szItemName)))
     {
   PostMessage(hwndClientDDE,
            WM_DDE_ACK,
      hwndServerDDE,
            MAKELONG(0, atomItem)); /* negative acknowledgement */
   return;
     }

     lstrcpy(szItemValue, lpPokeData->Value);
     if (pcCarriageReturn = strchr(szItemValue, '\r'))
         *pcCarriageReturn = 0;  /* remove CR/LF */
     SetDlgItemText(hwndMain, nItem, szItemValue);
     MaybeAdviseData(nItem);

     /* Save value of fRelease, since pointer may be invalidated by */
     /*  GlobalUnlock()              */
     bRelease = lpPokeData->fRelease;
     GlobalUnlock(hPokeData);

     if (bRelease)
     {
         GlobalFree(hPokeData);
     }

     /* Since we are re-using the item atom, we should not delete it */
     /* if PostMessage fails:  the client should delete the atom     */
     /* when it gets a time-out on the expected ACK.        */
     PostMessage(hwndClientDDE,
   WM_DDE_ACK,
   hwndServerDDE,
   MAKELONG(0x8000, atomItem));  /* positive acknowledgement */
     return;
 }



 /****************************************************************************

     FUNCTION: ServerRequest

     PURPOSE:  Called when server application receives WM_DDE_REQUEST message.

 ****************************************************************************/
 void ServerRequest(hwndServerDDE, hwndClientDDE, lParam)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     char szItem[ITEM_NAME_MAX_SIZE+1];
     char szItemValue[ITEM_VALUE_MAX_SIZE+1];
     int  nItem;

     GlobalGetAtomName(HIWORD(lParam), szItem, ITEM_NAME_MAX_SIZE);
     if (!(nItem = GetItemNumber(szItem))
   || (LOWORD(lParam) != CF_TEXT)) /* this app supports only CF_TEXT */
     {
   PostMessage(hwndClientDDE,
             WM_DDE_ACK,
       hwndServerDDE,
             MAKELONG(0, HIWORD(lParam))); /* NACK */
         return;
     }
     if (!GetDlgItemText(hwndMain, nItem, szItemValue, ITEM_VALUE_MAX_SIZE))
     {
   strcpy(szItemValue," ");
     }
     /* send now, don't defer, and don't ask for ACK */
     SendData(hwndServerDDE, hwndClientDDE, szItem, szItemValue, FALSE, FALSE)
     GlobalDeleteAtom(HIWORD(lParam));
     return;
 }


 /****************************************************************************

     FUNCTION: ServerTerminate

     PURPOSE:  Called when server application receives WM_DDE_TERMINATE messag

 ****************************************************************************/
 void ServerTerminate(hwndServerDDE, hwndClientDDE)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
 {

     if (!IsConvInTerminateState(hwndClientDDE))
     { /* Client has requested terminate: respond with terminate */
   PostMessage(hwndClientDDE, WM_DDE_TERMINATE, hwndServerDDE, 0L);
     }

     RemoveConv(hwndServerDDE);
     DestroyWindow(hwndServerDDE);
     return;
 }



 /****************************************************************************

     FUNCTION: ServerUnadvise

     PURPOSE:  Called when server application receives WM_DDE_UNADIVSE message

 ****************************************************************************/
 void ServerUnadvise(hwndServerDDE, hwndClientDDE, lParam)
     HWND  hwndServerDDE;
     HWND  hwndClientDDE;
     LONG  lParam;
 {
     char szItem[ITEM_NAME_MAX_SIZE+1];
     int  nItem;
     BOOL bSuccess;

     if (HIWORD(lParam))
     {
         GlobalGetAtomName(HIWORD(lParam), szItem, ITEM_NAME_MAX_SIZE);
         nItem = GetItemNumber(szItem);
   bSuccess = RemoveAdvise(hwndServerDDE, nItem);
     }
     else
     {   /* HIWORD(lParam)==0 means remove all advises */
   bSuccess = RemoveAdvise(hwndServerDDE, 0);
     }
     if (bSuccess)
     {
   PostMessage(hwndClientDDE,
             WM_DDE_ACK,
       hwndServerDDE,
             MAKELONG(0x8000, HIWORD(lParam))); /* positive ack */
     }
     else
     {
   PostMessage(hwndClientDDE,
             WM_DDE_ACK,
       hwndServerDDE,
             MAKELONG(0, HIWORD(lParam))); /* negative ack */
     }
     return;
 }

 /****************************************************************************

     FUNCTION: TerminateConversations

     PURPOSE:  Processes WM_DESTROY message, terminates all conversations.

 ****************************************************************************/
 void TerminateConversations()
 {
    HWND  hwndServerDDE;
    LONG  lTimeOut;
    MSG   msg;


    /* Terminate each active conversation */
    hwndServerDDE = NULL;
    while (hwndServerDDE = GetNextConv(hwndServerDDE))
    {
   SendTerminate(hwndServerDDE, GetHwndClientDDE(hwndServerDDE));
    }

    /* Wait for all conversations to terminate OR for time out */
    lTimeOut = GetTickCount() + (LONG)nAckTimeOut;
    while (PeekMessage(&msg, NULL, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
    {
          DispatchMessage (&msg);
    if (msg.message == WM_DDE_TERMINATE)
    {
        if (!AtLeastOneConvActive())
      break;
    }
          if (GetTickCount() > lTimeOut)
              break;
    }

    return;
 }


 SERVER.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\DDE\SERVER.C

 /***************************************************************************

     PROGRAM: SERVER

     PURPOSE: Illustrates server side of DDE conversation

     MODULES:

         SERVER.C    Window and dialog procedures.
   SERVDATA.C  Maintains conversation information.
         SERVDDE.C   Processes incoming and outgoing DDE messages.

 ****************************************************************************/

 #include "windows.h"
 #include "dde.h"
 #include "server.h"
 #include "servres.h"
 #include <string.h>
 #include <stdlib.h>



 static int     xDelta;
 static int     yDelta;

 long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);
 BOOL InitApplication(HANDLE);
 void InitAddedInstance(HANDLE, HANDLE);
 BOOL InitInstance(HANDLE, int);
 void MaybeAdviseData(int);
 BOOL FAR PASCAL AboutDlgProc(HWND, unsigned, WORD, LONG);


 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE:  Calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     MSG msg;
     HANDLE hAccel;

     if (!hPrevInstance)
     {
   if (!InitApplication(hInstance))
       return (FALSE);
     }
     else
     {
         InitAddedInstance(hInstance, hPrevInstance);
     }

     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     hAccel = LoadAccelerators(hInstance, "ServerAcc");

     while (GetMessage(&msg, NULL, NULL, NULL))
     {
   if (!TranslateAccelerator(hwndMain, hAccel, &msg))
   {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
   }

     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: InitApplication(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     nDoc = 1;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "ServerMenu";
     wc.lpszClassName = "ServerWClass";

     if (!RegisterClass(&wc))
   return (FALSE);

     wc.style = NULL;
     wc.lpfnWndProc = DDEWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = NULL;
     wc.hCursor = NULL;
     wc.hbrBackground = NULL;
     wc.lpszMenuName =  NULL;
     wc.lpszClassName = "ServerDDEWndClass";

     return (RegisterClass(&wc));
 }


 /****************************************************************************

     FUNCTION: InitAddedInstance

     PURPOSE:  Increment document number

 ****************************************************************************/
 void InitAddedInstance(hInstance, hPrevInstance)
     HANDLE  hInstance;
     HANDLE  hPrevInstance;
 {
     GetInstanceData(hPrevInstance, (NPSTR)&nDoc, sizeof(int));
     nDoc++;
     return;
 }



 /****************************************************************************

     FUNCTION:  InitInstance(HANDLE, int)

     PURPOSE:  Saves instance handle, creates main window, and creates
         3 child edit controls with id's 1, 2, and 3.

 ****************************************************************************/

 BOOL InitInstance(hInstance, nCmdShow)
     HANDLE          hInstance;
     int             nCmdShow;
 {
     char        szNumber[4];
     char        szCaption[20];
     HDC         hDC;
     PAINTSTRUCT ps;
     TEXTMETRIC  tm;
     int         nItem;
     int         nHorzRes, nVertRes;

     InitAckTimeOut(); /* in module SERVDDE */

     hInst = hInstance;

     strcpy(szDocName, "FILE");
     itoa(nDoc, szNumber, 10);
     strcat(szDocName, szNumber);
     strcpy(szCaption, "Server -- ");
     strcat(szCaption, szDocName);

     hwndMain = CreateWindow(
         "ServerWClass",
         szCaption,
         WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );

     if (!hwndMain)
         return (FALSE);

     hDC = GetDC(hwndMain);
     GetTextMetrics(hDC, (LPTEXTMETRIC)&tm);
     xDelta = tm.tmAveCharWidth;
     yDelta = tm.tmHeight + tm.tmExternalLeading;
     nHorzRes = GetDeviceCaps(hDC, HORZRES);
     nVertRes = GetDeviceCaps(hDC, VERTRES);
     ReleaseDC(hwndMain, hDC);

     MoveWindow(hwndMain,
   nHorzRes/2 + xDelta*(nDoc+5),
         ((nDoc-1)&1)*nVertRes/2 + yDelta*nDoc,
         xDelta*30,
   yDelta*12,
         FALSE);

     for (nItem = 1; nItem < 4; nItem++)
     {
         CreateWindow("edit", NULL,
       WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | WS_TABSTOP,
             9*xDelta, (2*nItem-1)*yDelta, 12*xDelta, (yDelta*3)/2,
       hwndMain, nItem, hInst, NULL);
     }

     if (!(cfLink = RegisterClipboardFormat("Link")))
   return (FALSE);

     ShowWindow(hwndMain, nCmdShow);
     UpdateWindow(hwndMain);


     return (TRUE);

 }

 /****************************************************************************

     FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for server

 ****************************************************************************/

 long FAR PASCAL MainWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     HDC  hDC;
     PAINTSTRUCT ps;
     HWND hctlItem;
     int  nItem;
     char szItemName[8];
     FARPROC lpAboutDlgProc;


     switch (message)
     {
         case WM_SETFOCUS:
             SetFocus(GetDlgItem(hwnd,1));
             break;

         case WM_PAINT:
       hDC = BeginPaint(hwnd, &ps);
             strcpy(szItemName, "Item1:");
             for (nItem = 1; nItem < 4; nItem++)
             {
     /* display labels for the edit controls */
                 TextOut(hDC, xDelta, (2*nItem-1)*yDelta, szItemName, 6);
                 szItemName[4]++;
             }
       EndPaint(hwnd, &ps);
             break;

         case WM_COMMAND:
             switch (wParam)
             {
                case IDM_COPY:
        hctlItem = GetFocus();
        for (nItem = 1; nItem <= 3; nItem++)
        {
            if (hctlItem == GetDlgItem(hwnd, nItem))
            {
          DoEditCopy(nItem);
          break;
            }
        }
        break;

          case ID_TAB:
          case ID_SHIFT_TAB:
        if (IsChild(hwndMain, GetFocus()))
        {
            nItem = GetWindowWord(GetFocus(), GWW_ID);
            if (wParam == ID_TAB)
            {
          if (nItem++ == 3)
              nItem = 1;
            }
            else
            {
          if (nItem-- == 1)
              nItem = 3;
            }
        }
        else
        {
            nItem = 1;
        }
        SetFocus(GetDlgItem(hwndMain, nItem));
        break;

          case 1:
                case 2:
                case 3:
                   if (HIWORD(lParam)==EN_KILLFOCUS)
                   {
                      hctlItem = GetDlgItem(hwnd, wParam);
                      if (SendMessage(hctlItem, EM_GETMODIFY, 0, 0L))
                      {
       MaybeAdviseData(wParam);
                         SendMessage(hctlItem, EM_SETMODIFY, 0, 0L);
                      }
                   }
                   break;

     case IDM_ABOUT:
         lpAboutDlgProc = MakeProcInstance(AboutDlgProc, hInst);
         DialogBox(hInst,
       "About",
       hwndMain,
       lpAboutDlgProc);
         FreeProcInstance(lpAboutDlgProc);
         break;
       }
             break;

         case WM_DDE_INITIATE:
             ServerInitiate((HWND)wParam, lParam);
             break;

         case WM_DESTROY:

             /* Terminate all DDE conversations before destroying
                client window */
       TerminateConversations();
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (0L);
 }



 /****************************************************************************

     FUNCTION: MaybeAdviseData

     PURPOSE:  Send data to all clients for which a hot or warm link
         has been established for the specified item.

 ****************************************************************************/
 void MaybeAdviseData(nItem)
     int   nItem;
 {
     HWND hwndServerDDE;
     char szItemName[ITEM_NAME_MAX_SIZE+1];
     char szItemValue[ITEM_VALUE_MAX_SIZE+1];
     BOOL bDeferUpdate;
     BOOL bAckRequest;

     hwndServerDDE = NULL;

     while (1)
     {
   if (hwndServerDDE = GetNextAdvise(hwndServerDDE, nItem))
         {
       GetAdviseData(hwndServerDDE,
                 nItem,
                 szItemName,
                 szItemValue,
                 &bDeferUpdate,
                 &bAckRequest);

       SendData(hwndServerDDE,
     GetHwndClientDDE(hwndServerDDE),
                 szItemName,
                 szItemValue,
                 bDeferUpdate,
                 bAckRequest);
         }
         else return;
     }
 }


 /****************************************************************************

     FUNCTION: AboutDlgProc(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

 ****************************************************************************/

 BOOL FAR PASCAL AboutDlgProc(hDlg, message, wParam, lParam)
     HWND hDlg;
     unsigned message;
     WORD wParam;
     LONG lParam;
 {
     switch (message) {
   case WM_INITDIALOG:
       return (TRUE);

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


 SHOWDIB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\SHOWDIB.C

 /****************************************************************************
  *                         *
  *  PROGRAM  : ShowDIB.c                   *
  *                         *
  *  PURPOSE  : Application to illustrate the use of the GDI           *
  *      DIB (Device Independent Bitmap) and Palette manager         *
  *      functions.                   *
  *                         *
  *  FUNCTIONS  : WinMain ()     -  Creates the app. window and enters *
  *              the message loop.           *
  *                         *
  *      WndProc()     -  Processes app. window messages.    *
  *                         *
  *      MenuCommand()    -  Processes menu commands.         *
  *                         *
  *      FreeDIB()     -  Frees currently active objects.    *
  *                         *
  *      InitDIB()     -  Reads DIB from a file and loads it.*
  *                         *
  ****************************************************************************

 #include <windows.h>
 #include <io.h>
 #include <stdio.h>
 #include "showdib.h"

 DIBPARAMS      DIBParams;       /* params for the SETSCALING escape */
 char         achFileName[128] = "";
 DWORD          dwOffset;
 NPLOGPALETTE   pLogPal;
 HPALETTE       hpalSave = NULL;
 HANDLE         hInst ;
 RECT         rcClip;
 extern         WORD _WinFlags;
 static         HCURSOR hcurSave;

 BOOL  fPalColors  = FALSE;        /* TRUE if the current DIB's color table
               /* contains palette indexes not rgb values */
 WORD  nAnimating  = 0;        /* Palette animation count     */
 WORD  UpdateCount = 0;

 BOOL  bMemoryDIB    = FALSE; /* Load Entire DIB into memory in CF_DIB format
 BOOL  bUpdateColors = TRUE;  /* Directly update screen colors          */
 BOOL  bDIBToDevice  = FALSE; /* Use SetDIBitsToDevice() to BLT data.
 BOOL  bNoUgly       = FALSE; /* Make window black on a WM_PALETTEISCHANGING
 BOOL  bLegitDraw    = FALSE; /* We have a valid bitmap to draw         */

 char  szBitmapExt[] = "*.BMP; *.DIB; *.RLE";     /* possible file extensions
 WORD  wTransparent  = TRANSPARENT;       /* Mode of DC         */
 char  szAppName[]   = "ShowDIB" ;       /* App. name          */

 HPALETTE hpalCurrent   = NULL;         /* Handle to current palette         *
 HANDLE   hdibCurrent   = NULL;         /* Handle to current memory DIB
 HBITMAP  hbmCurrent    = NULL;         /* Handle to current memory BITMAP
 HANDLE   hbiCurrent    = NULL;         /* Handle to current bitmap info struc
 HWND   hWndApp;           /* Handle to app. window          */

 /* Styles of app. window */
 DWORD         dwStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
        WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME;

 void PrintDIB (HWND hWnd, HDC hDC, int x, int y, int dx, int dy);
 /****************************************************************************
  *                      *
  *  FUNCTION   : WinMain(HANDLE, HANDLE, LPSTR, int)          *
  *                      *
  *  PURPOSE    : Creates the app. window and enters the message loop.      *
  *                      *
  ****************************************************************************
 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)

 HANDLE hInstance, hPrevInstance ;
 LPSTR  lpszCmdLine ;
 int    nCmdShow ;
 {
      HWND   hWnd ;
      WNDCLASS   wndclass ;
      MSG   msg ;
      short   xScreen, yScreen ;
      char   ach[40];

      hInst = hInstance ;

      /* default to MEMORY DIB's if XWindows */
      bMemoryDIB = WinFlags & WF_PMODE;

      /* Initialize clip rectangle */
      SetRectEmpty(&rcClip);

      if (!hPrevInstance) {
    wndclass.style   = CS_DBLCLKS;
    wndclass.lpfnWndProc  = WndProc ;
    wndclass.cbClsExtra  = 0 ;
    wndclass.cbWndExtra  = 0 ;
    wndclass.hInstance  = hInstance ;
    wndclass.hIcon   = LoadIcon(hInst, "SHOWICON");
    wndclass.hCursor  = LoadCursor (NULL, IDC_ARROW) ;
    wndclass.hbrBackground = GetStockObject (BLACK_BRUSH) ;
    wndclass.lpszMenuName  = szAppName ;
    wndclass.lpszClassName = szAppName ;

    if (!RegisterClass (&wndclass))
      return FALSE ;
      }

      if (!GetProfileString("extensions", "bmp", "", ach, sizeof(ach)))
        WriteProfileString("extensions", "bmp", "showdib.exe ^.bmp");
      if (!GetProfileString("extensions", "dib", "", ach, sizeof(ach)))
        WriteProfileString("extensions", "dib", "showdib.exe ^.dib");

      /* Save the pointer to the command line */
      lstrcpy(achFileName, lpszCmdLine);

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      /* Create the app. window */
      hWnd = CreateWindow( szAppName,
         szAppName,
         dwStyle,
         CW_USEDEFAULT,
         0,
         xScreen / 2,
         yScreen / 2,
         NULL,
         NULL,
         hInstance,
         NULL) ;

      ShowWindow (hWndApp = hWnd, nCmdShow) ;

      /* Enter message loop */
      while (GetMessage (&msg, NULL, 0, 0)) {
    TranslateMessage (&msg) ;
    DispatchMessage (&msg) ;
      }

      return msg.wParam ;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : WndProc (hWnd, iMessage, wParam, lParam)        *
  *                      *
  *  PURPOSE    : Processes window messages.            *
  *                      *
  ****************************************************************************
 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)

 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;

 {
     PAINTSTRUCT      ps;
     HDC        hDC;
     HANDLE       h;
     int        i;
     int        iMax;
     int        iMin;
     int        iPos;
     int        dn;
     RECT       rc,Rect;
     HPALETTE       hOldPal;
     HMENU       hMenu;

     switch (iMessage) {
   case WM_DESTROY:
     /* Clean up and quit */
     FreeDib();
     PostQuitMessage(0);
     break ;

   case WM_CREATE:
     /* Allocate space for our logical palette */
     pLogPal = (NPLOGPALETTE) LocalAlloc( LMEM_FIXED,
                  (sizeof(LOGPALETTE) +
                  (sizeof(PALETTEENTRY)*(MAXPALETTE))));

     /* If DIB initialization fails, quit */
     if (achFileName[0] && !InitDIB(hWnd))
       PostQuitMessage (3) ;

     /* fall through */

   case WM_WININICHANGE:

     hMenu = GetMenu(hWnd);

     /* If printer initialization succeeds, enable appropriate
      * menu item and clean up.
      */
     if ( hDC = GetPrinterDC() ) {
         EnableMenuItem( hMenu,
             IDM_PRINT,
             (RC_DIBTODEV &
              GetDeviceCaps(hDC, RASTERCAPS)) ?
              MF_ENABLED :
              MF_GRAYED | MF_DISABLED);
         DeleteDC(hDC);
     }

     break;

   case WM_PALETTEISCHANGING:
     /* if SHOWDIB was not responsible for palette change and if
      * ok to hide changes, paint app. window black.
      */
     if (wParam != hWnd && bNoUgly) {
         GetClientRect(hWnd, &Rect);

         hDC = GetDC(hWnd);
         FillRect( hDC, (LPRECT) &Rect, GetStockObject(BLACK_BRUSH));
         ReleaseDC(hWnd, hDC);
     }
     break;

   case WM_ACTIVATE:
     if (!wParam)  /* app. is being de-activated */
        break;
     /* If the app. is moving to the foreground, fall through and
      * redraw full client area with the newly realized palette,
      * if the palette has changed.
      */

   case WM_QUERYNEWPALETTE:
     /* If palette realization causes a palette change,
      * we need to do a full redraw.
      */
     if (bLegitDraw) {
         hDC = GetDC (hWnd);
         hOldPal = SelectPalette (hDC, hpalCurrent, 0);

         i = RealizePalette(hDC);

         SelectPalette (hDC, hOldPal, 0);
         ReleaseDC (hWnd, hDC);

         if (i) {
       InvalidateRect (hWnd, (LPRECT) (NULL), 1);
       UpdateCount = 0;
       return 1;
         } else
       return FALSE;
     }
     else
         return FALSE;
     break;

   case WM_PALETTECHANGED:
     /* if SHOWDIB was not responsible for palette change and if
      * palette realization causes a palette change, do a redraw.
      */
      if (wParam != hWnd){
         if (bLegitDraw){
       hDC = GetDC (hWnd);
       hOldPal = SelectPalette (hDC, hpalCurrent, 0);

       i = RealizePalette (hDC);

       if (i){
           if (bUpdateColors){
         UpdateColors (hDC);
         UpdateCount++;
           }
           else
         InvalidateRect (hWnd, (LPRECT) (NULL), 1);
       }

       SelectPalette (hDC, hOldPal, 0);
       ReleaseDC (hWnd, hDC);
         }
     }
     break;

   case WM_RENDERALLFORMATS:
     /* Ensure that clipboard data can be rendered even tho'
      * app. is being destroyed.
      */
     SendMessage(hWnd,WM_RENDERFORMAT,CF_DIB,0L);
     SendMessage(hWnd,WM_RENDERFORMAT,CF_BITMAP,0L);
     SendMessage(hWnd,WM_RENDERFORMAT,CF_PALETTE,0L);
     break;

   case WM_RENDERFORMAT:
     /* Format data in manner specified and pass the data
      * handle to clipboard.
      */
     if (h = RenderFormat(wParam))
         SetClipboardData(wParam,h);
     break;

   case WM_COMMAND:
     /* Process menu commands */
     return MenuCommand (hWnd, wParam);
     break;

   case WM_TIMER:
     /* Signal for palette animation */
     hDC = GetDC(hWnd);
     hOldPal = SelectPalette(hDC, hpalCurrent, 0);
     {
         PALETTEENTRY peTemp;

         /* Shift all palette entries left by one position and wrap
          * around the first entry
          */
         peTemp = pLogPal->palPalEntry[0];
         for (i = 0; i < (pLogPal->palNumEntries - 1); i++)
        pLogPal->palPalEntry[i] = pLogPal->palPalEntry[i+1];
         pLogPal->palPalEntry[i] = peTemp;
     }
     /* Replace entries in logical palette with new entries*/
     AnimatePalette(hpalCurrent, 0, pLogPal->palNumEntries, pLogPal->palPalEnt

     SelectPalette(hDC, hOldPal, 0);
     ReleaseDC(hWnd, hDC);

     /* Decrement animation count and terminate animation
      * if it reaches zero
      */
     if (!(--nAnimating))
         PostMessage(hWnd,WM_COMMAND,IDM_ANIMATE0,0L);
     break;

   case WM_PAINT:
     /* If we have updated more than once, the rest of our
      * window is not in some level of degradation worse than
      * our redraw...  we need to redraw the whole area
      */
     if (UpdateCount > 1) {
         BeginPaint(hWnd, &ps);
         EndPaint(hWnd, &ps);
         UpdateCount = 0;
         InvalidateRect(hWnd, (LPRECT) (NULL), 1);
         break;
     }

     hDC = BeginPaint(hWnd, &ps);
     AppPaint(hWnd,
        hDC,
        GetScrollPos(hWnd,SB_HORZ),
        GetScrollPos(hWnd,SB_VERT) );
     EndPaint(hWnd, &ps);
     break ;

   case WM_SIZE:
       SetScrollRanges(hWnd);
       break;

   case WM_KEYDOWN:
       /* Translate keyboard messages to scroll commands */
       switch (wParam) {
     case VK_UP:    PostMessage (hWnd, WM_VSCROLL, SB_LINEUP,   0L);
              break;

     case VK_DOWN:  PostMessage (hWnd, WM_VSCROLL, SB_LINEDOWN, 0L);
              break;

     case VK_PRIOR: PostMessage (hWnd, WM_VSCROLL, SB_PAGEUP,   0L);
              break;

     case VK_NEXT:  PostMessage (hWnd, WM_VSCROLL, SB_PAGEDOWN, 0L);
              break;

     case VK_HOME:  PostMessage (hWnd, WM_HSCROLL, SB_PAGEUP,   0L);
              break;

     case VK_END:   PostMessage (hWnd, WM_HSCROLL, SB_PAGEDOWN, 0L);
              break;

     case VK_LEFT:  PostMessage (hWnd, WM_HSCROLL, SB_LINEUP,   0L);
              break;

     case VK_RIGHT: PostMessage (hWnd, WM_HSCROLL, SB_LINEDOWN, 0L);
              break;
       }
       break;

   case WM_KEYUP:
       switch (wParam) {
          case VK_UP:
          case VK_DOWN:
          case VK_PRIOR:
          case VK_NEXT:
       PostMessage (hWnd, WM_VSCROLL, SB_ENDSCROLL, 0L);
       break;

          case VK_HOME:
          case VK_END:
          case VK_LEFT:
          case VK_RIGHT:
       PostMessage (hWnd, WM_HSCROLL, SB_ENDSCROLL, 0L);
       break;
       }
       break;

   case WM_VSCROLL:
       /* Calculate new vertical scroll position */
       GetScrollRange (hWnd, SB_VERT, &iMin, &iMax);
       iPos = GetScrollPos (hWnd, SB_VERT);
       GetClientRect (hWnd, &rc);

       switch (wParam) {
     case SB_LINEDOWN:      dn =  rc.bottom / 16 + 1;
                break;

     case SB_LINEUP:        dn = -rc.bottom / 16 + 1;
                break;

     case SB_PAGEDOWN:      dn =  rc.bottom / 2  + 1;
                break;

     case SB_PAGEUP:        dn = -rc.bottom / 2  + 1;
                break;

     case SB_THUMBTRACK:
     case SB_THUMBPOSITION: dn = LOWORD(lParam)-iPos;
                break;

     default:         dn = 0;
       }
       /* Limit scrolling to current scroll range */
       if (dn = BOUND (iPos + dn, iMin, iMax) - iPos) {
     ScrollWindow (hWnd, 0, -dn, NULL, NULL);
     SetScrollPos (hWnd, SB_VERT, iPos + dn, TRUE);
       }
       break;

   case WM_HSCROLL:
       /* Calculate new horizontal scroll position */
       GetScrollRange (hWnd, SB_HORZ, &iMin, &iMax);
       iPos = GetScrollPos (hWnd, SB_HORZ);
       GetClientRect (hWnd, &rc);

       switch (wParam) {
     case SB_LINEDOWN:      dn =  rc.right / 16 + 1;
                break;

     case SB_LINEUP:        dn = -rc.right / 16 + 1;
                break;

     case SB_PAGEDOWN:      dn =  rc.right / 2  + 1;
                break;

     case SB_PAGEUP:        dn = -rc.right / 2  + 1;
                break;

     case SB_THUMBTRACK:
     case SB_THUMBPOSITION: dn = LOWORD (lParam) - iPos;
                break;

     default:         dn = 0;
       }
       /* Limit scrolling to current scroll range */
       if (dn = BOUND (iPos + dn, iMin, iMax) - iPos) {
     ScrollWindow (hWnd, -dn, 0, NULL, NULL);
     SetScrollPos (hWnd, SB_HORZ, iPos + dn, TRUE);
       }
       break;

   case WM_LBUTTONDOWN:
       /* Start rubberbanding a rect. and track it's dimensions.
        * set the clip rectangle to it's dimensions.
        */
       TrackMouse (hWnd, MAKEPOINT (lParam));
       break;

   case WM_LBUTTONDBLCLK:
       break;

   case WM_INITMENU:
       /* check/uncheck menu items depending on state  of related
        * flags
        */
       CheckMenuItem(wParam, IDM_UPDATECOL,
     (bUpdateColors ? MF_CHECKED : MF_UNCHECKED));
       CheckMenuItem(wParam, IDM_TRANSPARENT,
     (wTransparent == TRANSPARENT ? MF_CHECKED : MF_UNCHECKED));
       CheckMenuItem(wParam, IDM_DIBSCREEN,
     (bDIBToDevice ? MF_CHECKED : MF_UNCHECKED));
       CheckMenuItem(wParam, IDM_NOUGLY,
     (bNoUgly ? MF_CHECKED : MF_UNCHECKED));
       CheckMenuItem(wParam, IDM_MEMORYDIB,
     (bMemoryDIB ? MF_CHECKED : MF_UNCHECKED));
       EnableMenuItem(wParam, IDM_PASTEDIB,
     IsClipboardFormatAvailable(CF_DIB)?MF_ENABLED:MF_GRAYED);
       EnableMenuItem(wParam, IDM_PASTEDDB,
     IsClipboardFormatAvailable(CF_BITMAP)?MF_ENABLED:MF_GRAYED);
       EnableMenuItem(wParam, IDM_PASTEPAL,
     IsClipboardFormatAvailable(CF_PALETTE)?MF_ENABLED:MF_GRAYED);
       EnableMenuItem(wParam, IDM_PRINT,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_SAVE,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_COPY,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);

       EnableMenuItem(wParam, IDM_ANIMATE0,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_ANIMATE5,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_ANIMATE50,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_ANIMATE100,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_ANIMATE200,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_ANIMATE201,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       EnableMenuItem(wParam, IDM_STEALCOL,
     bLegitDraw ? MF_ENABLED : MF_GRAYED);
       break;

   default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;

     }
     return 0L ;

 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : MenuCommand ( HWND hWnd, WORD wParam)          *
  *                      *
  *  PURPOSE    : Processes menu commands.            *
  *                      *
  *  RETURNS    : TRUE  - if command could be processed.         *
  *     FALSE - otherwise              *
  *                      *
  ****************************************************************************
 BOOL MenuCommand (hWnd, id)
 HWND hWnd;
 WORD id;

 {
     BITMAPINFOHEADER bi;
     HDC        hDC;
     HANDLE       h;
     HBITMAP       hbm;
     HPALETTE       hpal;
     int        i;
     char       Name[40];
     BOOL       bSave;
     int        xSize, ySize, xRes, yRes, dx, dy;
     RECT       Rect;
     int        fh;
     WORD       fFileOptions;

     switch (id) {
   case IDM_ABOUT:
     /* Show About .. box */
     fDialog (ABOUTBOX, hWnd,AppAbout);
     break;

   case IDM_COPY:
     if (!bLegitDraw)
         return 0L;

     /* Clean clipboard of contents */
     if (OpenClipboard(hWnd)) {
         EmptyClipboard ();
         SetClipboardData (CF_DIB   ,NULL);
         SetClipboardData (CF_BITMAP  ,NULL);
         SetClipboardData (CF_PALETTE ,NULL);
         CloseClipboard ();
     }
     break;

   case IDM_PASTEPAL:
     if (OpenClipboard (hWnd)) {
         if (h = GetClipboardData (CF_PALETTE)) {
       /* Delete current palette and get the CF_PALETTE data
        * from the clipboard
        */
       if (hpalCurrent)
           DeleteObject (hpalCurrent);

       hpalCurrent = CopyPalette (h);

       /*
        * If we have a bitmap realized against the old palette
        * delete the bitmap and rebuild it using the new palette.
        */
       if (hbmCurrent){
           DeleteObject (hbmCurrent);
           hbmCurrent = NULL;

           if (hdibCurrent)
         hbmCurrent = BitmapFromDib (hdibCurrent, hpalCurrent);
       }
         }
         CloseClipboard();
     }
     break;

   case IDM_PASTEDIB:
     if (OpenClipboard (hWnd)) {
         if (h = GetClipboardData (CF_DIB)) {
       /* Delete current DIB and get CF_DIB and
        * CF_PALETTE format data from the clipboard
        */
       hpal = GetClipboardData (CF_PALETTE);

       FreeDib();
       hdibCurrent = CopyHandle (h);
       if (hdibCurrent) {
           bLegitDraw = TRUE;
           lstrcpy(achFileName,"<Clipboard>");
           hbiCurrent = hdibCurrent;

           /* If there is a CF_PALETTE object in the
            * clipboard, this is the palette to assume
            * the DIB should be realized against, otherwise
            * create a palette for it.
            */
           if (hpal)
         hpalCurrent = CopyPalette (hpal);
           else
         hpalCurrent = CreateDibPalette (hdibCurrent);

           SizeWindow(hWnd);
       }
       else {
           bLegitDraw = FALSE;
           ErrMsg("No Memory Available!");
       }
         }
         CloseClipboard();
     }
     break;

   case IDM_PASTEDDB:
     if (OpenClipboard (hWnd)) {
         if (hbm = GetClipboardData(CF_BITMAP)) {
       hpal = GetClipboardData(CF_PALETTE);
       FreeDib();

       /*
        * If there is a CF_PALETTE object in the
        * clipboard, this is the palette to assume
        * the bitmap is realized against.
        */
       if (hpal)
           hpalCurrent = CopyPalette(hpal);
       else
           hpalCurrent = GetStockObject(DEFAULT_PALETTE);

       hdibCurrent = DibFromBitmap(hbm,BI_RGB,0,hpalCurrent);

       if (hdibCurrent) {
           bLegitDraw = TRUE;
           lstrcpy(achFileName,"<Clipboard>");
           hbiCurrent = hdibCurrent;

           if (bMemoryDIB)
         hbmCurrent = BitmapFromDib (hdibCurrent, hpalCurrent);

           SizeWindow(hWnd);
       }
       else {
           bLegitDraw = FALSE;
           ErrMsg("No Memory Available!");
       }
         }
         CloseClipboard ();
     }
     break;

   case IDM_PRINT:
     GetWindowText(hWnd, Name, sizeof(Name));

     DibInfo(hbiCurrent, &bi);

     if (!IsRectEmpty(&rcClip))
     {
         bi.biWidth  = rcClip.right  - rcClip.left;
         bi.biHeight = rcClip.bottom - rcClip.top;
     }

     /* Initialise printer stuff */
     if (!(hDC = GetPrinterDC()))
       break;

     xSize = GetDeviceCaps(hDC, HORZRES);
     ySize = GetDeviceCaps(hDC, VERTRES);
     xRes  = GetDeviceCaps(hDC, LOGPIXELSX);
     yRes  = GetDeviceCaps(hDC, LOGPIXELSY);

     /* Use half inch margins on left and right
      * and one inch on top. Maintain the same aspect ratio.
      */

     dx = xSize - xRes;
     dy = (int)((long)dx * bi.biHeight/bi.biWidth);

     /* Fix bounding rectangle for the picture .. */
     Rect.top    = yRes;
     Rect.left   = xRes / 2;
     Rect.bottom = yRes + dy;
     Rect.right  = xRes / 2 + dx;

     /* ... and inform the driver */
     Escape(hDC, SET_BOUNDS, sizeof(RECT), (LPSTR)&Rect, NULL);

     bSave = TRUE;

     if (InitPrinting(hDC, hWnd, hInst, Name)) {

       PrintDIB(hWnd, hDC, xRes/2, yRes, dx, dy);

       /* Signal to the driver to begin translating the drawing
        * commands to printer output...
        */
       Escape (hDC, NEWFRAME, NULL, NULL, NULL);

       TermPrinting(hDC);
     }

     DeleteDC(hDC);
     break;

   case IDM_OPEN:
     /* Bring up File/Open ... dialog */
     fh = DlgOpenFile (hWnd,
           "Select a DIB to display",
           (LONG)OF_EXIST | OF_MUSTEXIST | OF_NOOPTIONS,
           szBitmapExt,
           achFileName,
           NULL
           );

     /*  Load up the DIB if the user did not press cancel */
     if (fh > 0) {
        StartWait();
        if (InitDIB (hWnd))
            InvalidateRect (hWnd, NULL, FALSE);
        else
            bLegitDraw = FALSE;
        EndWait();
     }
     break;

   case IDM_SAVE:
     DibInfo(hbiCurrent,&bi);
     fFileOptions = 0;

     /* Depending on compression type for current DIB,
      * set the appropriate bit in the fFileOptions flag
      */
     if (bi.biCompression == BI_RGB)
         fFileOptions |= F_RGB;
     else if (bi.biCompression == BI_RLE4)
         fFileOptions |= F_RLE4;
     else if (bi.biCompression == BI_RLE8)
         fFileOptions |= F_RLE8;

     /* Depending on bits/pixel type for current DIB,
      * set the appropriate bit in the fFileOptions flag
      */
     switch (bi.biBitCount){
         case  1:
       fFileOptions |= F_1BPP;
       break;

         case  4:
       fFileOptions |= F_4BPP;
       break;

         case  8:
       fFileOptions |= F_8BPP;
       break;

         case 24:
       fFileOptions |= F_24BPP;
     }

     /* Bring up File/Save... dialog and get info. about filename,
      * compression, and bits/pix. of DIB to be written.
      */
     fh = DlgOpenFile (hWnd,
           "Select File to save DIB to",
           (LONG)OF_EXIST | OF_SAVE | OF_NOSHOWSPEC,
           szBitmapExt,
           achFileName,
           &fFileOptions);

     /* Extract DIB specs. if the user did not press cancel */
     if (fh != 0){
         if (fFileOptions & F_RGB)
       bi.biCompression = BI_RGB;

         if (fFileOptions & F_RLE4)
       bi.biCompression = BI_RLE4;

         if (fFileOptions & F_RLE8)
       bi.biCompression = BI_RLE8;

         if (fFileOptions & F_1BPP)
       bi.biBitCount = 1;

         if (fFileOptions & F_4BPP)
       bi.biBitCount = 4;

         if (fFileOptions & F_8BPP)
       bi.biBitCount = 8;

         if (fFileOptions & F_24BPP)
       bi.biBitCount = 24;

         /* Realize a DIB in the specified format and obtain a
          * handle to it.
          */
         hdibCurrent = RealizeDibFormat(bi.biCompression,bi.biBitCount);
         if (!hdibCurrent){
       ErrMsg("Unable to save the specified file");
       return 0L;
         }

         /* Write the DIB */
         StartWait();
         if (!WriteDIB(achFileName,hdibCurrent))
       ErrMsg("Unable to save the specified file");
         EndWait();
     }
     break;

   case IDM_EXIT:
     PostMessage(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
     break;

   case IDM_UPDATECOL:
     /* Toggle state of "update screen colors" flag. If it is
      * off, clear the "hide changes" flag
      */
     bUpdateColors = !bUpdateColors;
     if (bUpdateColors)
         bNoUgly = 0;
     break;

   case IDM_DIBSCREEN:
     bDIBToDevice = !bDIBToDevice;
     InvalidateRect(hWnd, (LPRECT) (NULL), 1);
     break;

   case IDM_MEMORYDIB:
     bMemoryDIB = !bMemoryDIB;
     break;

   case IDM_NOUGLY:
     /* Toggle state of "hide changes" flag. If it is off, clear
      * the "update screen colors" flag. This will tell SHOWDIB
      * to paint itself black while the palette is changing.
      */
     bNoUgly = !bNoUgly;
     if (bNoUgly)
         bUpdateColors = 0;
     break;

   case IDM_TRANSPARENT:
     /* Toggle DC mode */
     wTransparent = wTransparent == TRANSPARENT ?
         OPAQUE : TRANSPARENT;
     break;

   case IDM_ANIMATE0:
     if (!hpalSave)
         break;

     /* Reset animation count and stop timer */
     KillTimer(hWnd, 1);
     nAnimating = 0;

     /* Restore palette which existed before animation started */
     DeleteObject(hpalCurrent);
     hpalCurrent = hpalSave;

     /* Rebuild bitmap based on newly realized information */
     hDC = GetDC (hWnd);
     SelectPalette (hDC, hpalCurrent, 0);
     RealizePalette (hDC);
     ReleaseDC (hWnd, hDC);

     if (hbmCurrent){
         DeleteObject (hbmCurrent);
         hbmCurrent = NULL;

         if (hdibCurrent)
            hbmCurrent = BitmapFromDib (hdibCurrent, hpalCurrent);
     }
     hpalSave = NULL;

     /* Force redraw with new palette for everyone */
     InvalidateRect(hWnd, NULL, TRUE);
     break;

   case IDM_STEALCOL:
   case IDM_ANIMATE5:
   case IDM_ANIMATE20:
   case IDM_ANIMATE50:
   case IDM_ANIMATE100:
   case IDM_ANIMATE200:
   case IDM_ANIMATE201:
     /* Set animation count i.e number of times animation is to
      * take place.
      */
     nAnimating = id;
     if (id == IDM_STEALCOL)
       nAnimating = 0;

     /* Save current palette */
     hpalSave = CopyPalette(hpalCurrent);

     GetObject(hpalCurrent, sizeof(int), (LPSTR)&pLogPal->palNumEntries);
     GetPaletteEntries(hpalCurrent, 0, pLogPal->palNumEntries, pLogPal->palPal

     /* Reserve all entries in the palette otherwise AnimatePalette()
      * will not modify them
      */
     for (i = 0; i < pLogPal->palNumEntries; i++) {
          pLogPal->palPalEntry[i].peFlags = (BYTE)PC_RESERVED;
     }

     SetPaletteEntries(hpalCurrent, 0, pLogPal->palNumEntries, pLogPal->palPal

     /* Rebuild bitmap based on newly realized information */
     if (hbmCurrent){
         DeleteObject (hbmCurrent);
         hbmCurrent = NULL;

         if (hdibCurrent)
            hbmCurrent = BitmapFromDib (hdibCurrent, hpalCurrent);
     }

     /* Force redraw with new palette for everyone */
     InvalidateRect(hWnd, NULL, TRUE);

     /* Initiate the timer so that palette can be animated in
      * response to a WM_TIMER message
      */
     if (nAnimating && !SetTimer(hWnd, 1, 250, (LPSTR) NULL))
       nAnimating = 0;

   default:
     break;
     }

     return TRUE;
 }

 /****************************************************************************
  *                      *
  *  FUNCTION   : InitDIB(hWnd)                *
  *                      *
  *  PURPOSE    : Reads a DIB from a file, obtains a handle to it's          *
  *     BITMAPINFO struct., sets up the palette and loads the DIB. *
  *                      *
  *  RETURNS    : TRUE  - DIB loads ok              *
  *     FALSE - otherwise              *
  *                      *
  ****************************************************************************
 int InitDIB(hWnd)
 HWND hWnd;
 {
     unsigned         fh;
     LPBITMAPINFOHEADER lpbi;
     WORD FAR *         pw;
     int          i;
     BITMAPINFOHEADER   bi;
     OFSTRUCT         of;

     FreeDib();

     /* Open the file and get a handle to it's BITMAPINFO */

     fh = OpenFile (achFileName, (LPOFSTRUCT)&of, OF_READ);
     if (fh == -1) {
   ErrMsg("Can't open file '%ls'", (LPSTR)achFileName);
   return FALSE;
     }
     hbiCurrent = ReadDibBitmapInfo(fh);

     dwOffset = _llseek(fh, 0L, SEEK_CUR);
     _lclose (fh);

     if (hbiCurrent == NULL) {
   ErrMsg("%ls is not a Legitimate DIB File!", (LPSTR)achFileName);
   return FALSE;
     }
     DibInfo(hbiCurrent,&bi);

     /* Set up the palette */
     hpalCurrent = CreateDibPalette(hbiCurrent);
     if (hpalCurrent == NULL) {
   ErrMsg("CreatePalette() Failed");
   return FALSE;
     }

     /*  Convert the DIB color table to palette relative indexes, so
      *  SetDIBits() and SetDIBitsToDevice() can avoid color matching.
      *  We can do this because the palette we realize is identical
      *  to the color table of the bitmap, ie the indexes match 1 to 1
      *
      *  Now that the DIB color table is palette indexes not RGB values
      *  we must use DIB_PAL_COLORS as the wUsage parameter to SetDIBits()
      */
     lpbi = (VOID FAR *)GlobalLock(hbiCurrent);
     if (lpbi->biBitCount != 24) {
   fPalColors = TRUE;

   pw = (WORD FAR *)((LPSTR)lpbi + lpbi->biSize);

   for (i=0; i<(int)lpbi->biClrUsed; i++)
       *pw++ = (WORD)i;
     }
     GlobalUnlock(hbiCurrent);
     bLegitDraw = TRUE;

     /*  If the input bitmap is not in RGB FORMAT the banding code will
      *  not work!  we need to load the DIB bits into memory.
      *  if memory DIB, load it all NOW!  This will avoid calling the
      *  banding code.
      */
     if (bMemoryDIB || bi.biCompression != BI_RGB)
   hdibCurrent = OpenDIB(achFileName);

     /*  If the RLE could not be loaded all at once, exit gracefully NOW,
      *  to avoid calling the banding code
      */
     if ((bi.biCompression != BI_RGB) && !hdibCurrent){
   ErrMsg ("Could not load RLE!");
   FreeDib();
   return FALSE;
     }

     if (hdibCurrent && !bDIBToDevice && bMemoryDIB){
   hbmCurrent = BitmapFromDib(hdibCurrent,hpalCurrent);
   if (!hbmCurrent){
       ErrMsg ("Could not create bitmap!");
       FreeDib();
       return FALSE;
   }
     }

     SizeWindow(hWnd);

     return TRUE;
 }
 /****************************************************************************
  *                      *
  *  FUNCTION   : FreeDib(void)                *
  *                      *
  *  PURPOSE    : Frees all currently active bitmap, DIB and palette objects *
  *     and initializes their handles.           *
  *                      *
  ****************************************************************************
 void FreeDib(void)
 {
     if (hpalCurrent)
   DeleteObject(hpalCurrent);

     if (hbmCurrent)
   DeleteObject(hbmCurrent);

     if (hdibCurrent)
   GlobalFree(hdibCurrent);

     if (hbiCurrent && hbiCurrent != hdibCurrent)
   GlobalFree(hbiCurrent);

     fPalColors  = FALSE;
     bLegitDraw  = FALSE;
     hpalCurrent = NULL;
     hdibCurrent = NULL;
     hbmCurrent  = NULL;
     hbiCurrent  = NULL;
     SetRectEmpty (&rcClip);
 }


 SHOWFONT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWFONT\SHOWFONT.C

 /****************************************************************************

     PROGRAM: Showfont.c

     PURPOSE: Adds, deletes, creates and displays fonts

     FUNCTIONS:

         WinMain() - calls initialization function, processes message loop
         EditfileInit() - initializes window data and registers window
         EditfileWndProc() - processes messages
         About() - processes messages for "About" dialog box
         SelectFont() - select a font
         GetSizes() - get size of current font
         GetFonts() - get available fonts
         SetMyDC() - initializes DC
         Metric() - Metric dialog box
         Log() - Log dialog box
         AddDlg() - dialog box for adding a font
         RemoveDlg() - dialog box for removing a font
         CFontDlg()
         _lstrcpy() - long strcpy()
         _lstrncpy() - long strncpy()
         _lstrlen()  - long strlen()
         CheckFileName() - check for valid filename
         SeparateFile() - Separate filename and pathname
         UpdateListBox() - update file list box
         AddExt() - add default extension
         SetFaceName() - update title with current font's face name

 ****************************************************************************/

 #include "windows.h"
 #include "showfont.h"

 HANDLE hInst;

 HFONT hOFont, hFFont, hVFont, hSFont, hDFont, hMFont, hFont;
 int hFile;
 char line[4][64];
 char FontNameList[32][128];                          /* list of added fonts
 int nFontIndex = 0;                                  /* position in FontList
 int nLineSpace;

 TEXTMETRIC TextMetric;
 LOGFONT LogFont;
 FARPROC lpCFontDlg;
 POINT ptCurrent = {0, 0};
 short nBkMode = OPAQUE;
 DWORD rgbBkColor = RGB(255, 255, 255);
 DWORD rgbTextColor = RGB(0, 0, 0);
 DWORD rgbColor;
 short nAlignLCR = TA_LEFT;
 short nAlignTBB = TA_TOP;
 WORD wPaint = 0;
 FARPROC lpColors;
 char FontList[MAXFONT][32];
 BYTE CharSet[MAXFONT];
 BYTE PitchAndFamily[MAXFONT];
 int FontIndex = 0;
 int SizeList[MAXSIZE];
 int SizeIndex = 0;
 int CurrentFont = 0;
 int CurrentSize = 0;
 FARPROC lpSelectFont;
 FARPROC lpEnumFunc;
 WORD wPrevVAlign = IDM_ALIGNBASE;
 WORD wPrevHAlign = IDM_ALIGNLEFT;
 WORD wPrevFont = IDM_SYSTEM;
 char AppName[] = "ShowFont Sample Application   Font: ";
 char WindowTitle[80];
 char str[255];
 char DefPath[128];
 char DefExt[] = ".fon";
 char DefSpec[13];
 char FontFileName[128];

 /****************************************************************************

     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

     PURPOSE: calls initialization function, processes message loop

 ****************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int nCmdShow;
 {
     HWND hWnd;
     MSG msg;

     if (!hPrevInstance)
         if (!ShowFontInit(hInstance))
             return (FALSE);

     hInst = hInstance;

     strcpy(WindowTitle, AppName);
     strcat(WindowTitle, "SYSTEM");                 /* default is SYSTEM font

     hWnd = CreateWindow("ShowFont",
         WindowTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL);

     if (!hWnd)
         return (FALSE);

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

     while (GetMessage(&msg, NULL, NULL, NULL)) {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
     }
     return (msg.wParam);
 }

 /****************************************************************************

     FUNCTION: ShowFontInit(HANDLE)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 int ShowFontInit(hInstance)
 HANDLE hInstance;
 {
     HANDLE hMemory;
     PWNDCLASS pWndClass;
     BOOL bSuccess;

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->lpszMenuName = (LPSTR) "ShowFont";
     pWndClass->lpszClassName = (LPSTR) "ShowFont";
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->hInstance = hInstance;
     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = ShowFontWndProc;

     bSuccess = RegisterClass((LPWNDCLASS) pWndClass);

     LocalUnlock(hMemory);
     LocalFree(hMemory);
     return (bSuccess);
 }

 /****************************************************************************

     FUNCTION: SetMyDC(HDC)

     PURPOSE: Initializes the DC

 ****************************************************************************/

 HDC SetMyDC(hDC)
 HDC hDC;
 {
     SetBkMode(hDC, nBkMode);
     SetBkColor(hDC, rgbBkColor);
     SetTextColor(hDC, rgbTextColor);
     SetTextAlign(hDC, nAlignLCR | nAlignTBB);
 }

 /****************************************************************************

     FUNCTION: GetStringExtent(HDC, PSTR, HFONT)

     PURPOSE: get the string extent

 ****************************************************************************/

 short GetStringExtent(hDC, pString, hFont)
 HDC hDC;
 PSTR pString;
 HFONT hFont;
 {
     HFONT hOldFont;
     DWORD dwExtent;

     if (hOldFont=SelectObject(hDC, hFont)) {
         dwExtent = GetTextExtent(hDC, pString, strlen(pString));
         SelectObject(hDC, hOldFont);
         return (LOWORD(dwExtent));
     }
     else
         return (0);
 }

 /****************************************************************************

     FUNCTION: GetStringExtent(HDC, PSTR, HFONT)

     PURPOSE: Sends string to application's window

 ****************************************************************************/

 short StringOut(hDC, X, Y, pString, hFont)
 HDC hDC;
 short X;
 short Y;
 PSTR pString;
 HFONT hFont;
 {
     HFONT hOldFont;
     DWORD dwExtent;

     hOldFont = SelectObject(hDC, hFont);
     if (hOldFont != NULL) {
         dwExtent = GetTextExtent(hDC, pString, strlen(pString));
         TextOut(hDC, X, Y, pString, strlen(pString));
         SelectObject(hDC, hOldFont);
     }
     return (LOWORD(dwExtent));
 }

 /****************************************************************************

     FUNCTION: ShowString(HWND)

     PURPOSE: Show string in current font

 ****************************************************************************/

 void ShowString(hWnd)
 HWND hWnd;
 {
     HFONT hItalicFont;
     HFONT hBoldFont;
     HFONT hUnderlineFont;
     HFONT hStrikeOutFont;
     HDC hDC;
     short X, tmpX;
     short Y;
     short nAlign;

     GetObject(hFont, sizeof(LOGFONT), (LPSTR) &LogFont);
     LogFont.lfItalic = TRUE;
     hItalicFont = CreateFontIndirect(&LogFont);
     LogFont.lfItalic = FALSE;
     LogFont.lfUnderline = TRUE;
     hUnderlineFont = CreateFontIndirect(&LogFont);
     LogFont.lfUnderline = FALSE;
     LogFont.lfStrikeOut = TRUE;
     hStrikeOutFont = CreateFontIndirect(&LogFont);
     LogFont.lfStrikeOut = FALSE;
     LogFont.lfWeight = FW_BOLD;
     hBoldFont = CreateFontIndirect(&LogFont);

     hDC=GetDC(hWnd);
     SetMyDC(hDC);
     X=ptCurrent.x;
     Y=ptCurrent.y;
     nAlign =  nAlignLCR | nAlignTBB;                   /* GetTextAlign(hDC);
     if ((nAlign & TA_CENTER) == TA_CENTER) {
         tmpX = X;
         nAlignLCR = TA_LEFT;
         SetTextAlign(hDC, nAlignLCR | nAlignTBB);
         X += StringOut(hDC, X, Y, ", and ", hFont);
         X += StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X += StringOut(hDC, X, Y, " in a single line.", hFont);
         X = tmpX;
         nAlignLCR = TA_RIGHT;
         SetTextAlign(hDC, nAlignLCR | nAlignTBB);
         X -= StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "italic", hItalicFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "bold", hBoldFont);
         X -= StringOut(hDC, X, Y, "You can use ", hFont);
         nAlignLCR = TA_CENTER;
     }
     else if ((nAlign & TA_CENTER) == TA_RIGHT) {
         X -= StringOut(hDC, X, Y, " in a single line.", hFont);
         X -= StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X -= StringOut(hDC, X, Y, ", and ", hFont);
         X -= StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "italic", hItalicFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "bold", hBoldFont);
         X -= StringOut(hDC, X, Y, "You can use ", hFont);
     }
     else  {
         X += StringOut(hDC, X, Y, "You can use ", hFont);
         X += StringOut(hDC, X, Y, "bold", hBoldFont);
         X += StringOut(hDC, X, Y, ", ", hFont);
         X += StringOut(hDC, X, Y, "italic", hItalicFont);
         X += StringOut(hDC, X, Y, ", ", hFont);
         X += StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X += StringOut(hDC, X, Y, ", and ", hFont);
         X += StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X += StringOut(hDC, X, Y, " in a single line.", hFont);
     }
     ReleaseDC(hWnd, hDC);

     DeleteObject(hItalicFont);
     DeleteObject(hUnderlineFont);
     DeleteObject(hStrikeOutFont);
     DeleteObject(hBoldFont);
 }

 /****************************************************************************

     FUNCTION: ShowCharacterSet(HDC, HFONT)

     PURPOSE: display character set using current font

 ****************************************************************************/

 void ShowCharacterSet(hDC, hFont)
 HDC hDC;
 HFONT hFont;
 {
     HFONT hOldFont;
     TEXTMETRIC TextMetric;
     int LineSpace;
     short X;
     short Y;

     if (!(hOldFont = SelectObject(hDC, hFont)))
         return;
     GetTextMetrics(hDC, &TextMetric);
     nLineSpace = (TextMetric.tmHeight + TextMetric.tmExternalLeading)*2;
     X = ptCurrent.x;
     Y = ptCurrent.y;
     TextOut(hDC, X, Y, line[0], 64);
     TextOut(hDC, X, Y += nLineSpace, line[1], 64);
     TextOut(hDC, X, Y += nLineSpace, line[2], 64);
     TextOut(hDC, X, Y += nLineSpace, line[3], 64);
     SelectObject(hDC, hOldFont);
 }

 /****************************************************************************

     FUNCTION: ShowLogFont(HWND, HFONT)

     PURPOSE: Create dialog box to show information about logical font

 ****************************************************************************/

 void ShowLogFont(hWnd, hFont)
 HWND hWnd;
 HFONT hFont;
 {
     HFONT hOldFont;
     FARPROC lpProcLog;
     HDC hDC;
     TEXTMETRIC TextMetric;
     HANDLE hDlgBox;
     char buf[80];
     char DialogTitle[100];

     hDC = GetDC(hWnd);
     if (!(hOldFont = SelectObject(hDC, hSFont)))
         return;
     GetTextMetrics(hDC, &TextMetric);
     nLineSpace = TextMetric.tmHeight + TextMetric.tmExternalLeading;
     GetObject(hFont, sizeof(LOGFONT), (LPSTR) &LogFont);

     lpProcLog = MakeProcInstance((FARPROC) Log, hInst);
     hDlgBox = CreateDialog(hInst, "LogBox", hWnd, lpProcLog);

     strcpy(DialogTitle, "Log Font: ");
     strcat(DialogTitle, LogFont.lfFaceName);
     SetWindowText(hDlgBox, (LPSTR) DialogTitle);

     SelectObject(hDC, hOldFont);
     ReleaseDC(hWnd, hDC);
 }

 /****************************************************************************

     FUNCTION: ShowMetricFont(HWND, HFONT)

     PURPOSE: Create dialog box to show information about metric font

 ****************************************************************************/

 void ShowTextMetric(hWnd, hFont)
 HWND hWnd;
 HFONT hFont;
 {
     FARPROC lpProcMetric;
     HFONT hOldFont;
     TEXTMETRIC LocalTextMetric;
     HDC hDC;
     HANDLE hDlgBox;
     char buf[80];
     char DialogTitle[100];

     hDC = GetDC(hWnd);
     if (!(hOldFont = SelectObject(hDC, hFont)))
         return;
     GetTextMetrics(hDC, &TextMetric);

     lpProcMetric = MakeProcInstance((FARPROC) Metric, hInst);
     hDlgBox = CreateDialog(hInst, "MetricBox", hWnd, lpProcMetric);

     strcpy(DialogTitle, "Metric Font: ");
     GetTextFace(hDC, 80, buf);
     strcat(DialogTitle, buf);
     SetWindowText(hDlgBox, (LPSTR) DialogTitle);

     SelectObject(hDC, hOldFont);
     ReleaseDC(hWnd, hDC);
 }

 /****************************************************************************

     FUNCTION: Colors(HWND, unsigned, WORD LONG)

     PURPOSE: Dialog box for changing background color of text

 ****************************************************************************/

 BOOL FAR PASCAL Colors(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     int Red, Green, Blue;

     switch (message) {
         case WM_INITDIALOG:
             SetDlgItemInt(hDlg, ID_RED, GetRValue(rgbColor), FALSE);
             SetDlgItemInt(hDlg, ID_GREEN, GetGValue(rgbColor), FALSE);
             SetDlgItemInt(hDlg, ID_BLUE, GetBValue(rgbColor), FALSE);
             return (TRUE);
             break;

         case WM_COMMAND:
             switch (wParam) {
                 case IDOK:
                     Red = GetDlgItemInt(hDlg, ID_RED, NULL, FALSE);
                     Green = GetDlgItemInt(hDlg, ID_GREEN, NULL, FALSE);
                     Blue = GetDlgItemInt(hDlg, ID_BLUE, NULL, FALSE);
                     rgbColor = RGB(Red, Green, Blue);
                     EndDialog(hDlg, 1);
                     break;

                 case IDCANCEL:
                     EndDialog(hDlg, 0);
                     break;
             }
             break;
     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: EnumFunc(LPLOGFONT, LPTEXTMETRIC, short, LPSTR)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 int FAR PASCAL EnumFunc(lpLogFont, lpTextMetric, FontType, lpData)
 LPLOGFONT lpLogFont;
 LPTEXTMETRIC lpTextMetric;
 short FontType;
 LPSTR lpData;
 {
     switch (LOWORD(lpData)) {
         case 0:
             if (FontIndex >= MAXFONT)
                 return (0);
             _lstrcpy((LPSTR) FontList[FontIndex],
                 (LPSTR) (lpLogFont->lfFaceName));
             CharSet[FontIndex] = lpLogFont->lfCharSet;
             PitchAndFamily[FontIndex] = lpLogFont->lfPitchAndFamily;
             return (++FontIndex);

         case 1:
             if (SizeIndex >= MAXSIZE)
                 return (0);
             SizeList[SizeIndex] = lpLogFont->lfHeight;
             return (++SizeIndex);
     }
 }

 /****************************************************************************

     FUNCTION: GetFonts(HWND)

     PURPOSE: Get available fonts

 ****************************************************************************/

 void GetFonts(hWnd)
 HWND hWnd;
 {

     HDC hDC;

     FontIndex = 0;
     SizeIndex = 0;
     hDC = GetDC(hWnd);
     lpEnumFunc = MakeProcInstance(EnumFunc, hInst);
     EnumFonts(hDC, (LPSTR) NULL, lpEnumFunc, (LPSTR) NULL);
     FreeProcInstance(lpEnumFunc);
     ReleaseDC(hWnd, hDC);
 }

 /****************************************************************************

     FUNCTION: GetSizes(hWnd, CurrentFont)

     PURPOSE: Get size of current font

 ****************************************************************************/

 void GetSizes(hWnd, CurrentFont)
 HWND hWnd;
 int CurrentFont;
 {
     HDC hDC;

     SizeIndex = 0;
     hDC = GetDC(hWnd);
     lpEnumFunc = MakeProcInstance(EnumFunc, hInst);
     EnumFonts(hDC, FontList[CurrentFont], lpEnumFunc, (LPSTR) 1L);
     FreeProcInstance(lpEnumFunc);
     ReleaseDC(hWnd, hDC);
 }


 /****************************************************************************

     FUNCTION: SelectFont(HWND, unsigned, WORD, LONG)

     PURPOSE: Initializes window data and registers window class

 ****************************************************************************/

 BOOL FAR PASCAL SelectFont(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {

     int i;
     int index;
     char buf[LF_FACESIZE];

     switch (message) {
         case WM_INITDIALOG:
             for (i=0; i<FontIndex; i++) {        /* displays available fonts
                 SendDlgItemMessage(hDlg, ID_TYPEFACE, LB_ADDSTRING,
                     NULL, (LONG) (LPSTR) FontList[i]);
                 SendDlgItemMessage(hDlg, ID_TYPEFACE, LB_SETCURSEL,
                     0, 0L);
             }
             GetSizes(hDlg, 0);
             for (i=0; i<SizeIndex; i++) {        /* displays font sizes
                 sprintf(buf, "%d", SizeList[i]);
                 SendDlgItemMessage(hDlg, ID_SIZE, LB_ADDSTRING,
                     0, (LONG) (LPSTR) buf);
                 SendDlgItemMessage(hDlg, ID_SIZE, LB_SETCURSEL,
                     0, 0L);
             }
             return (TRUE);
             break;

         case WM_COMMAND:
             switch (wParam) {
                 case IDOK:
 okay:
                     index=SendDlgItemMessage(hDlg, ID_TYPEFACE,
                         LB_GETCURSEL, 0, 0L);
                     if (index == LB_ERR) {
                         MessageBox(hDlg, "No font selected",
                             "Select Font", MB_OK | MB_ICONEXCLAMATION);
                     break;
             }
             CurrentFont = index;
             index = SendDlgItemMessage(hDlg, ID_SIZE,
                 LB_GETCURSEL, 0, 0L);
             if (index == LB_ERR) {
                 MessageBox(hDlg, "No size selected",
                     "Select Font", MB_OK | MB_ICONEXCLAMATION);
                 break;
             }
             CurrentSize = index;
             EndDialog(hDlg, 1);
             break;

         case IDCANCEL:
             EndDialog(hDlg, 0);
             break;

         case ID_TYPEFACE:
             switch (HIWORD(lParam)) {
                 case LBN_SELCHANGE:
                     index = SendDlgItemMessage(hDlg, ID_TYPEFACE,
                         LB_GETCURSEL, 0, 0L);
                     if (index == LB_ERR)
                         break;
                     SendDlgItemMessage(hDlg, ID_SIZE, LB_RESETCONTENT, 0, 0L)
                     GetSizes(hDlg, index);
                     for (i = 0; i < SizeIndex; i++) {
                         sprintf(buf, "%d", SizeList[i]);
                         SendDlgItemMessage(hDlg, ID_SIZE,
                             LB_ADDSTRING, 0, (LONG) (LPSTR) buf);
                         SendDlgItemMessage(hDlg, ID_SIZE, LB_SETCURSEL, 0, 0L
             }
             break;

                 case LBN_DBLCLK:
                 goto okay;
                 break;
             }
             break;

         case ID_SIZE:
             if(HIWORD(lParam) == LBN_DBLCLK)
                 goto okay;
             break;
         }
         break;
     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: ShowFontWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE: Processes messages

 ****************************************************************************/

 long FAR PASCAL ShowFontWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpAddDlg, lpRemoveDlg;
     HDC hDC;
     PAINTSTRUCT ps;
     HFONT hOldFont;
     int i;
     short Y;
     char buf[80];

     switch(message) {
         case WM_CREATE:
             GetFonts(hWnd);
             hMFont = CreateFont(
                 10,                                      /* height
                 10,                                      /* width
                 0,                                       /* escapement
                 0,                                       /* orientation
                 FW_NORMAL,                               /* weight
                 FALSE,                                   /* italic
                 FALSE,                                   /* underline
                 FALSE,                                   /* strikeout
                 OEM_CHARSET,                             /* charset
                 OUT_DEFAULT_PRECIS,                      /* out precision
                 CLIP_DEFAULT_PRECIS,                     /* clip precision
                 DEFAULT_QUALITY,                         /* quality
                 FIXED_PITCH | FF_MODERN,                 /* pitch and family
                 "Courier");                              /* typeface
             hOFont = GetStockObject(OEM_FIXED_FONT);
             hFFont = GetStockObject(ANSI_FIXED_FONT);
             hVFont = GetStockObject(ANSI_VAR_FONT);
             hSFont = GetStockObject(SYSTEM_FONT);
             hDFont = GetStockObject(DEVICE_DEFAULT_FONT);
             hFont = hSFont;
             GetObject(hFont, sizeof(LOGFONT), (LPSTR) &LogFont);
             strcpy(WindowTitle, AppName);
             strcat(WindowTitle, "SYSTEM");
             SetWindowText(hWnd, (LPSTR) WindowTitle);

             for (i=0; i<64; i++) {
                 line[0][i] = i;
                 line[1][i] = i+64;
                 line[2][i] = i+128;
                 line[3][i] = i+192;
             }
             break;

         case WM_PAINT:
             hDC = BeginPaint(hWnd, &ps);
             SetMyDC(hDC);
             switch (wPaint) {
                 case IDM_SHOWCHARSET:
                 ShowCharacterSet(hDC, hFont);
                 break;
             }
             EndPaint(hWnd, &ps);
             break;

         case WM_COMMAND:
             switch (wParam) {

                 /* File menu */

                 case IDM_ADDFONT:

                     /* Call AddDlg() to get the filename */

                     lpAddDlg = MakeProcInstance((FARPROC) AddDlg, hInst);
                     if (DialogBox(hInst, "Add", hWnd, lpAddDlg)) {

                         /* Check to see if it is a new font name */

                         for (i = 0; i < nFontIndex; i++) {
                             if (!strcmp(FontFileName, &FontNameList[i][0])) {
                                 MessageBox(hWnd, "Font already exists",
                                     "Add Font", MB_OK | MB_ICONQUESTION);
                                 FreeProcInstance(lpAddDlg);
                                 return (0L);
                             }
                         }

                         /* Tell Windows to add the font resource */

                         AddFontResource((LPSTR) FontFileName);

                         /* Let all applications know there is a new font
                          * resource
                          */

                         SendMessage((HWND) 0xFFFF, WM_FONTCHANGE, NULL,
                             (LONG) NULL);

                         /* Copy the name selected to the list of fonts added

                         strcpy(&FontNameList[nFontIndex++][0], FontFileName);
                     }

                     FreeProcInstance(lpAddDlg);
                     break;

                 case IDM_DELFONT:
                     if (!nFontIndex) {
                         MessageBox(hWnd, "No fonts to delete",
                             "Remove Font", MB_OK | MB_ICONQUESTION);
                         break;
                     }

                     lpRemoveDlg = MakeProcInstance((FARPROC) RemoveDlg, hInst
                     if (DialogBox(hInst, "Remove", hWnd, lpRemoveDlg)) {
                         for (i = 0; i < nFontIndex; i++) {
                             if (!strcmp(FontFileName, &FontNameList[i][0])) {
                                 RemoveFontResource((LPSTR) FontFileName);
                                 SendMessage((HWND) 0xFFFF, WM_FONTCHANGE, NUL
                                     (LONG) NULL);
                                 strcpy(&FontNameList[i][0],
                                     &FontNameList[--nFontIndex][0]);
                                 break;
                             }
                         }
                     }
                     FreeProcInstance(lpRemoveDlg);
                     break;

                 case IDM_EXIT:
                     DestroyWindow(hWnd);
                     break;

                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance((FARPROC) About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 /* Show menu */

                 case IDM_SHOWSTRING:
                     ShowString(hWnd);
                     break;

                 case IDM_SHOWCHARSET:
                     InvalidateRect(hWnd, (LPRECT)NULL, TRUE);
                     wPaint = wParam;
                     break;

                 case IDM_SHOWLOGFONT:
                     ShowLogFont(hWnd, hFont);
                     break;

                 case IDM_SHOWTEXTMETRICS:
                     ShowTextMetric(hWnd, hFont);
                     break;

                 case IDM_CLEAR:
                     InvalidateRect(hWnd, (LPRECT)NULL, TRUE);
                     wPaint = 0;
                     break;

                 /* Font menu */

                 case IDM_OEM:
                     hFont = hOFont;
                     SetFaceName(hWnd);                  /* sets window title
                     CheckMenuItem(GetMenu(hWnd), wPrevFont, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevFont = wParam;
                     break;

                 case IDM_ANSIFIXED:
                     hFont = hFFont;
                     SetFaceName(hWnd);
                     CheckMenuItem(GetMenu(hWnd), wPrevFont, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevFont = wParam;
                     break;

                 case IDM_ANSIVAR:
                     hFont = hVFont;
                     SetFaceName(hWnd);
                     CheckMenuItem(GetMenu(hWnd), wPrevFont, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevFont = wParam;
                     break;

                 case IDM_SYSTEM:
                     hFont = hSFont;
                     SetFaceName(hWnd);
                     CheckMenuItem(GetMenu(hWnd), wPrevFont, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevFont = wParam;
                     break;

                 case IDM_DEVICEDEF:
                     hFont = hDFont;
                     SetFaceName(hWnd);
                     CheckMenuItem(GetMenu(hWnd), wPrevFont, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevFont = wParam;
                     break;

                 case IDM_SELECTFONT:
                     lpSelectFont = MakeProcInstance(SelectFont, hInst);
                     if (DialogBox(hInst, "SelectFont", hWnd, lpSelectFont)) {
                         DeleteObject(hMFont);
                         hMFont = CreateFont(
                             SizeList[CurrentSize],
                             0,
                             0,
                             0,
                             FW_NORMAL,
                             FALSE,
                             FALSE,
                             FALSE,
                             CharSet[CurrentFont],
                             OUT_DEFAULT_PRECIS,
                             CLIP_DEFAULT_PRECIS,
                             DEFAULT_QUALITY,
                             PitchAndFamily[CurrentFont],
                             FontList[CurrentFont]);
                         hFont = hMFont;
                         SetFaceName(hWnd);
                     }
                     FreeProcInstance(lpSelectFont);
                     break;

                 case IDM_CFONT:
                     lpCFontDlg = MakeProcInstance(CFontDlg, hInst);
                     GetObject(hMFont, sizeof(LOGFONT), (LPSTR) &CLogFont);
                     if (DialogBox(hInst, "CFont", hWnd, lpCFontDlg)) {
                         DeleteObject(hMFont);
                         hMFont = CreateFontIndirect(&CLogFont);
                         hFont = hMFont;
                         SetFaceName(hWnd);
                     }
                     FreeProcInstance(lpCFontDlg);
                     break;

                 /* Options menu */

                 case IDM_TEXTCOLOR:
                     lpColors = MakeProcInstance(Colors, hInst);
                     rgbColor = rgbTextColor;
                     if (DialogBox(hInst, "Colors", hWnd, lpColors))
                         rgbTextColor = rgbColor;
                     FreeProcInstance(lpColors);
                     break;

                 case IDM_BACKGROUNDCOLOR:
                     lpColors = MakeProcInstance(Colors, hInst);
                     rgbColor = rgbBkColor;
                     if (DialogBox(hInst, "Colors", hWnd, lpColors))
                         rgbBkColor = rgbColor;
                     FreeProcInstance(lpColors);
                     break;

                 case IDM_OPAQUE:
                     nBkMode = OPAQUE;
                     CheckMenuItem(GetMenu(hWnd), IDM_TRANSPARENT, MF_UNCHECKE
                     CheckMenuItem(GetMenu(hWnd), IDM_OPAQUE, MF_CHECKED);
                     break;

                 case IDM_TRANSPARENT:
                     nBkMode = TRANSPARENT;
                     CheckMenuItem(GetMenu(hWnd), IDM_OPAQUE,  MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), IDM_TRANSPARENT,  MF_CHECKED
                     break;

                 case IDM_ALIGNLEFT:
                     nAlignLCR = TA_LEFT;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNCENTER:
                     nAlignLCR = TA_CENTER;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNRIGHT:
                     nAlignLCR = TA_RIGHT;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNTOP:
                     nAlignTBB = TA_TOP;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;

                 case IDM_ALIGNBASE:
                     nAlignTBB = TA_BASELINE;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;

                 case IDM_ALIGNBOTTOM:
                     nAlignTBB = TA_BOTTOM;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;
             }
             break;

         case WM_LBUTTONUP:
             ptCurrent.x = LOWORD(lParam);
             ptCurrent.y = HIWORD(lParam);
             ShowString(hWnd);
             break;

         case WM_FONTCHANGE:
             GetFonts(hWnd);
             break;

         case WM_DESTROY:

             /* Remove any fonts that were added */

             for (i = 0; i < nFontIndex; i++)
                 RemoveFontResource((LPSTR) &FontNameList[i][0]);

             /* Notify any other applications know the fonts have been deleted

             SendMessage((HWND) 0xFFFF, WM_FONTCHANGE, NULL, (LONG) NULL);
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (0L);
 }

 /****************************************************************************

     FUNCTION: Metric(HWND, unsigned, WORD, LONG)

     PURPOSE: Modeless dialog box to display metric font information

 ****************************************************************************/

 BOOL FAR PASCAL Metric(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             SetDlgItemInt(hDlg, IDMB_HEIGHT, TextMetric.tmHeight, FALSE);
             SetDlgItemInt(hDlg, IDMB_ASCENT, TextMetric.tmAscent, FALSE);
             SetDlgItemInt(hDlg, IDMB_DESCENT, TextMetric.tmDescent, FALSE);
             SetDlgItemInt(hDlg, IDMB_INTERNALLEADING,
                 TextMetric.tmInternalLeading, FALSE);
             SetDlgItemInt(hDlg, IDMB_EXTERNALLEADING,
                 TextMetric.tmExternalLeading, FALSE);
             SetDlgItemInt(hDlg, IDMB_AVECHARWIDTH, TextMetric.tmAveCharWidth,
                 FALSE);
             SetDlgItemInt(hDlg, IDMB_MAXCHARWIDTH, TextMetric.tmMaxCharWidth,
                 FALSE);
             SetDlgItemInt(hDlg, IDMB_WEIGHT, TextMetric.tmWeight, FALSE);
             SetDlgItemInt(hDlg, IDMB_ITALIC, TextMetric.tmItalic, FALSE);
             SetDlgItemInt(hDlg, IDMB_UNDERLINED, TextMetric.tmUnderlined,
                 FALSE);
             SetDlgItemInt(hDlg, IDMB_STRUCKOUT, TextMetric.tmStruckOut, FALSE
             SetDlgItemInt(hDlg, IDMB_FIRSTCHAR, TextMetric.tmFirstChar, FALSE
             SetDlgItemInt(hDlg, IDMB_LASTCHAR, TextMetric.tmLastChar, FALSE);
             SetDlgItemInt(hDlg, IDMB_DEFAULTCHAR, TextMetric.tmDefaultChar,
                 FALSE);
             SetDlgItemInt(hDlg, IDMB_BREAKCHAR, TextMetric.tmBreakChar, FALSE
             SetDlgItemInt(hDlg, IDMB_PITCHANDFAMILY,
                 TextMetric.tmPitchAndFamily, FALSE);
             SetDlgItemInt(hDlg, IDMB_CHARSET, TextMetric.tmCharSet, FALSE);
             SetDlgItemInt(hDlg, IDMB_OVERHANG, TextMetric.tmOverhang, FALSE);
             SetDlgItemInt(hDlg, IDMB_DIGITIZEDASPECTX,
                 TextMetric.tmDigitizedAspectX, FALSE);
             SetDlgItemInt(hDlg, IDMB_DIGITIZEDASPECTY,
     TextMetric.tmDigitizedAspectY, FALSE);
             return (TRUE);

         case WM_CLOSE:
             DestroyWindow(hDlg);
             break;
     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: Log(HWND, unsigned, WORD, LONG)

     PURPOSE: Displays logical font information

 ****************************************************************************/

 BOOL FAR PASCAL Log(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {

     switch (message) {
         case WM_INITDIALOG:
             SetDlgItemInt(hDlg, IDMI_HEIGHT, LogFont.lfHeight, FALSE);
             SetDlgItemInt(hDlg, IDMI_WIDTH, LogFont.lfWidth, FALSE);
             SetDlgItemInt(hDlg, IDMI_ESCAPEMENT, LogFont.lfEscapement, FALSE)
             SetDlgItemInt(hDlg, IDMI_ORIENTATION, LogFont.lfOrientation, FALS
             SetDlgItemInt(hDlg, IDMI_WEIGHT, LogFont.lfWeight, FALSE);
             SetDlgItemInt(hDlg, IDMI_ITALIC, LogFont.lfItalic, FALSE);
             SetDlgItemInt(hDlg, IDMI_UNDERLINED, LogFont.lfUnderline, FALSE);
             SetDlgItemInt(hDlg, IDMI_STRIKEOUT, LogFont.lfStrikeOut, FALSE);
             SetDlgItemInt(hDlg, IDMI_CHARSET, LogFont.lfCharSet, FALSE);
             SetDlgItemInt(hDlg, IDMI_OUTPRECISION, LogFont.lfOutPrecision,
                 FALSE);
             SetDlgItemInt(hDlg, IDMI_CLIPPRECISION, LogFont.lfClipPrecision,
                 FALSE);
             SetDlgItemInt(hDlg, IDMI_QUALITY, LogFont.lfQuality, FALSE);
             SetDlgItemInt(hDlg, IDMI_PITCHANDFAMILY,
                 LogFont.lfPitchAndFamily, FALSE);
             return (TRUE);

         case WM_CLOSE:
             DestroyWindow(hDlg);
             break;

     }
     return (FALSE);
 }

 /****************************************************************************

     FUNCTION: AddDlg(HWND, unsigned, WORD, LONG)

     PURPOSE: Used to add a font

     COMMENTS:

         This dialog box displays all the availble font files on the currently
         selected directory, and lets the user select a font to add.

 ****************************************************************************/

 BOOL FAR PASCAL AddDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_COMMAND:
             switch (wParam) {
                 case ID_LISTBOX:

                     switch (HIWORD(lParam)) {
                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
                             if (DlgDirSelect(hDlg, str, ID_LISTBOX))
                                 strcat(str, DefSpec);

                             SetDlgItemText(hDlg, ID_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 ID_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));
                             break;

                         case LBN_DBLCLK:
                             goto CheckSelection;
                             break;

                     }                              /* end of ID_LISTBOX case
                     return (TRUE);

                 case IDOK:
 CheckSelection:
                     /* Get the filename from the edit control */

                     GetDlgItemText(hDlg, ID_EDIT, str, 128);
                     GetDlgItemText(hDlg, ID_PATH, DefPath, 128);

                     /* Check for wildcard.  If found, use the string as a new
                      * search path.
                      */

                     if (strchr(str, '*') ||
                         strchr(str, '?')) {

                     /* Separate filename from path.  The path is stored in
                      * str which is discarded if null, else it is used for a
                      * search path.
                      */

                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) str);
                         if (str[0])
                             strcpy(DefPath, str);

                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     /* Ignore it if no filename specified */

                     if (!str[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONQUESTION);
                         return (TRUE);
                     }

                     /* Append the default extension if needed */

                     strcpy(FontFileName, DefPath);
                     strcat(FontFileName, str);
                     AddExt(FontFileName, DefExt);
                     EndDialog(hDlg, TRUE);
                     return (TRUE);

                 case IDCANCEL:

                     /* Let the caller know the user cancelled */

                     EndDialog(hDlg, FALSE);
                     return (TRUE);
             }
             break;

         case WM_INITDIALOG:
             SetWindowText(hDlg, (LPSTR) "Add Font Resource");
             strcpy(DefSpec, "*.fon");
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, ID_EDIT, DefSpec);
             SendDlgItemMessage(hDlg, ID_EDIT, EM_SETSEL, NULL,
                 MAKELONG(0, 0x7fff));
             SetFocus(GetDlgItem(hDlg, ID_EDIT));
             return (FALSE);
     }
     return FALSE;
 }

 /****************************************************************************

     FUNCTION: RemoveDlg(HANDLE)

     PURPOSE: Used to remove a font

     COMMENTS:

         This dialog box displays all fonts which have been added to the syste
         and lets the user select which font to delete.

 ****************************************************************************/

 BOOL FAR PASCAL RemoveDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     WORD index;
     int i;

     switch (message) {
         case WM_COMMAND:

             switch (wParam) {
                 case ID_LISTBOX:

                     switch (HIWORD(lParam)) {
                         case LBN_SELCHANGE:
                             index = SendDlgItemMessage(hDlg,
                                 ID_LISTBOX,
                                 LB_GETCURSEL,         /* get index command
                                 NULL,
                                 (LONG) NULL);
                             SendDlgItemMessage(hDlg,
                                 ID_LISTBOX,
                                 LB_GETTEXT,           /* copy string command
                                 index,
                                 (LONG) (LPSTR) FontFileName);
                             SetDlgItemText(hDlg, ID_EDIT, FontFileName);
                             break;

                         case LBN_DBLCLK:
                             GetDlgItemText(hDlg, ID_EDIT, FontFileName, 128);
                             EndDialog(hDlg, TRUE);
                             return (TRUE);
                     }
                     return (TRUE);

                 case IDOK:

                     /* Get the filename from the edit control */

                     GetDlgItemText(hDlg, ID_EDIT, FontFileName, 128);

                     /* Ignore it if no filename specified */

                     if (!FontFileName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONQUESTION);
                         return (TRUE);
                     }

                     EndDialog(hDlg, TRUE);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, FALSE);
                     return (TRUE);
             }
             break;

         case WM_INITDIALOG:
             SetWindowText(hDlg, (LPSTR) "Remove Font Resource");
             for (i = 0; i < nFontIndex; i++)
                 SendDlgItemMessage(hDlg,
                     ID_LISTBOX,
                     LB_ADDSTRING,
                     NULL,
                     (LONG)(char far *) &FontNameList[i][0]);

             SetFocus(GetDlgItem(hDlg, ID_EDIT));
             return (FALSE);
     }
     return FALSE;
 }

 /****************************************************************************

     FUNCTION: UpdateListBox(HWND);

     PURPOSE: Update the list box of OpenDlg

 ****************************************************************************/

 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, ID_LISTBOX, ID_PATH, 0x4010);
     SetDlgItemText(hDlg, ID_EDIT, DefSpec);
 }

 /****************************************************************************

     FUNCTION: AddExt(PSTR, PSTR);

     PURPOSE: Add default extension

 /***************************************************************************/

 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }

 /****************************************************************************

     FUNCTION: SeparateFile(HWND, LPSTR, LPSTR, LPSTR)

     PURPOSE: Separate filename and pathname

     COMMENTS:

         This function takes a source filespec and splits it into a path and a
         filename, and copies these into the strings specified.  Because it
         uses the AnsiPrev call, it will work in any language.

 ****************************************************************************/

 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;

     lpTmp = lpSrcFileName + (long) _lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {                  /* no path given
         _lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     _lstrcpy(lpDestFileName, lpTmp + 1L);
     _lstrncpy(lpDestPath, lpSrcFileName, (int) (lpTmp - lpSrcFileName) + 1);
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }

 /****************************************************************************

     FUNCTION: _lstrlen(LPSTR)

     PURPOSE:  uses a long far pointer to the string, returns the length

 ****************************************************************************/

 int _lstrlen(lpStr)
 LPSTR lpStr;
 {
     int i;
     for (i=0; *lpStr++; i++);
     return (i);
 }

 /****************************************************************************

     FUNCTION: _lstrncpy(LPSTR, LPSTR)

     PURPOSE:  FAR version of strncpy()

 ****************************************************************************/

 void _lstrncpy(lpDest, lpSrc, n)
 LPSTR lpDest, lpSrc;
 int n;
 {
     while (n--)
         if(!(*lpDest++ = *lpSrc++))
             return;
 }

 /****************************************************************************

     FUNCTION: _lstrcpy(LPSTR, LPSTR)

     PURPOSE:  FAR version of strcpy()

 ****************************************************************************/

 void _lstrcpy(lpDest, lpSrc)
 LPSTR lpDest, lpSrc;
 {
     while(*lpDest++ = *lpSrc++);
 }

 /****************************************************************************

     FUNCTION: SetFaceName(HWND)

     PURPOSE: Retireves current font's face name, places it in WindowTitle

 ****************************************************************************/

 SetFaceName(hWnd)
 HWND hWnd;
 {
     char buf[80];
     HDC hDC;

     hDC = GetDC(hWnd);
     SelectObject(hDC, hFont);
     strcpy(WindowTitle, AppName);
     GetTextFace(hDC, 80, buf);
     strcat(WindowTitle, buf);
     SetWindowText(hWnd, (LPSTR) WindowTitle);

     ReleaseDC(hWnd, hDC);
 }

 /****************************************************************************

     FUNCTION: About(HWND, unsigned, WORD, LONG)

     PURPOSE:  Processes messages for "About" dialog box

     MESSAGES:

         WM_INITDIALOG - initialize dialog box
         WM_COMMAND    - Input received

 ****************************************************************************/

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

         case WM_COMMAND:
             if (wParam == IDOK) {
                 EndDialog(hDlg, TRUE);
                 return (TRUE);
             }
             return (TRUE);
     }
     return (FALSE);
 }


 TTY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\TTY\TTY.C

 //

 //  FILE:    TTY.c

 //  PURPOSE: This sample terminal application demonstrates
 //          the basic uses of Windows Communications functions.
 //          It also shows the basic structure for a terminal program.

 //  FUNCTIONS:
 //          WinMain() - Initializes app, calls all other functions.
 //          TTYWndProc() - Window procedure for terminal window.
 //          About() - Window procedure for About dialog box.
 //          AboutInit() - Initialization procedure for About dialog box.
 //          SettingDlgProc() - Window procedure for Comm Settings dialog.
 //

 #include <windows.h>
 #include <string.h>
 #include "wstdio.h"
 #include "tty.h"


 //========================================================================\\

 // Declarations

 //========================================================================\\

 #define COM1  "com1"
 #define COM2  "com2"
 #define CommSettings "com1:96,n,8,1"

 #define BufMax      160     // Size of line buffer used for displaying text
 #define cbInBuf    1024    // Size of receive buffer
 #define cbOutBuf   128     // size of transmit buffer

 DCB CommDCB;               // DCB for comm port
 int PortID;                // The comm port id
 COMSTAT CommStat;          // COMSTAT info buffer for comm port
 char MsgBuff[BufMax + 1];  // Buffer to hold incoming characters
 BOOL bConnected;           // Flag to indicate if connected
 short nCommErr;            // Storage for communications error data
 WORD wCommEvt;             // Storage for communications event data

 HWND hTTYWnd;              // Handle to application window

 char sTemp[256];

 static HANDLE hInst;       // Global instance handle
 FARPROC lpprocAbout;       // Pointer to "About" dialog box procedure
 FARPROC lpfnOldTTYProc;    // Pointer to TTY proc prior to subclassing

 long FAR PASCAL TTYWndProc(HWND, unsigned, WORD, LONG);


 //========================================================================\\

 // FUNCTION: About(HWND, unsigned, WORD, LONG)

 // PURPOSE:  Processes messages for About dialog box.

 //========================================================================\\

 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     if (message == WM_COMMAND
   || message == WM_LBUTTONDOWN) {

   // if we click the mouse in the dialog, or press 'Enter', then go away
         EndDialog( hDlg, TRUE );
         return TRUE;
         }
     else if (message == WM_INITDIALOG)
         return TRUE;
     else return FALSE;
 }


 //========================================================================\\

 // FUNCTION: AboutInit(HWND, HANDLE)

 // PURPOSE:  About box initialization.

 //========================================================================\\

 BOOL AboutInit(HWND hWnd, HANDLE hInstance)
 {
     HMENU hMenu;

     /* Bind callback function with module instance */
     lpprocAbout = MakeProcInstance( (FARPROC)About, hInstance );

     return TRUE;
 }


 //========================================================================\\

 // FUNCTION: SettingDlgProc(HWND, unsigned, WORD, LONG)

 // PURPOSE:  Processes messages for Communications Settings dialog.

 //========================================================================\\

 BOOL FAR PASCAL SettingDlgProc( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
    int theButton;
    static DCB dlgDCB;

    switch(message) {
       case WM_COMMAND:

          // if the Ok button is pressed the new settings are saved

          if(wParam == IDOK) {
             // save the new settings
             CommDCB = dlgDCB;
             // close the dialog
             EndDialog( hDlg, TRUE );

          } else

          // otherwise, the settings are not saved and changes are discarded

             if(wParam == IDCANCEL)
                EndDialog(hDlg,FALSE);
             else
                if(HIWORD(lParam) == BN_CLICKED) {

                   // if a button is clicked and it is a radiobutton,
                   // then we uncheck the current selection and check
                   // the one that was clicked.

                   HWND hStartWnd = GetDlgItem(hDlg,wParam);

                   if(LOWORD(GetWindowLong(hStartWnd,GWL_STYLE))
                      == BS_AUTORADIOBUTTON){
                      HWND hCurrWnd = hStartWnd;
                      do{
                         hCurrWnd = GetNextDlgGroupItem(hDlg,hCurrWnd,1);
                         SendMessage(hCurrWnd, BM_SETCHECK, hCurrWnd == hStart
                         } while(hCurrWnd != hStartWnd);
                   }

       // now we set the appropriate value in the DCB for the
       // button that was clicked

       switch (wParam){
                             case RBBAUD_300: dlgDCB.BaudRate = 300; break;
                             case RBBAUD_1200: dlgDCB.BaudRate = 1200; break;
                             case RBBAUD_2400: dlgDCB.BaudRate = 2400; break;
           case RBBAUD_9600: dlgDCB.BaudRate = 9600; break;

                             case RBDBITS_7: dlgDCB.ByteSize = 7; break;
           case RBDBITS_8: dlgDCB.ByteSize = 8; break;

                             case RBPARITY_EVEN: dlgDCB.Parity = EVENPARITY; b
                             case RBPARITY_ODD: dlgDCB.Parity = ODDPARITY; bre
           case RBPARITY_NONE: dlgDCB.Parity = NOPARITY; break;

                             case RBSBITS_2: dlgDCB.StopBits = TWOSTOPBITS; br
           case RBSBITS_1: dlgDCB.StopBits = ONESTOPBIT; break;

           case CBXONXOFF: dlgDCB.fInX = dlgDCB.fInX?0:1; break;

                             case RBPORT_COM1: dlgDCB.Id = 1; break;
                             case RBPORT_COM2: dlgDCB.Id = 2; break;
                         }
         } else
                        return FALSE;

             break;

   case WM_INITDIALOG:

     // make a copy of the current DCB
     // we will change this copy, and copy back to the original
     // if we click Ok

     dlgDCB = CommDCB;

     // set buttons as reflected by the current DCB

     // if the current port isn't com2, set com1 button
     theButton = (dlgDCB.Id == 2 ? RBPORT_COM2 : RBPORT_COM1);
     SendDlgItemMessage(hDlg,theButton,BM_SETCHECK,1,0L);

     // set baud button
                 switch(dlgDCB.BaudRate){
                     case 300: theButton = RBBAUD_300; break;
                     case 1200: theButton = RBBAUD_1200; break;
                     case 2400: theButton = RBBAUD_2400; break;
                     case 9600: theButton = RBBAUD_9600; break;
                     default: theButton = RBBAUD_300; break;
     }
     SendDlgItemMessage(hDlg,theButton,BM_SETCHECK,1,0L);

     // set data bits button. if it's not 8, then it's 7
                 theButton = (dlgDCB.ByteSize == 8 ? RBDBITS_8 : RBDBITS_7);
     SendDlgItemMessage(hDlg,theButton,BM_SETCHECK,1,0L);

     // set parity button
                 switch(dlgDCB.Parity){
                     case EVENPARITY: theButton = RBPARITY_EVEN; break;
                     case ODDPARITY: theButton = RBPARITY_ODD; break;
                     case NOPARITY: theButton = RBPARITY_NONE; break;
                     default: theButton = RBPARITY_NONE; break;
                 }
     SendDlgItemMessage(hDlg,theButton,BM_SETCHECK,1,0L);

     // set stop bits button. if it's not 2, then it's 1
                 theButton = (dlgDCB.StopBits == TWOSTOPBITS ? RBSBITS_2 : RBS
     SendDlgItemMessage(hDlg,theButton,BM_SETCHECK,1,0L);

     // set Xon/Xoff check box to on or off
     SendDlgItemMessage(hDlg,CBXONXOFF,BM_SETCHECK,dlgDCB.fInX,0L);

             break;

         default:
             return FALSE;
     }
     return TRUE;
 }


 //========================================================================\\

 // FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)

 // PURPOSE:  Main procedure of the application.

 //========================================================================\\

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     BOOL bMsgAvail;
     short iNumRead,iError;

     hInst = hInstance;

     // initialize the stdio window library
     if(!hPrevInstance)
         if(!stdioInit(hInstance)) return FALSE;

     // create a stdio window
     if(!(hTTYWnd = CreateStdioWindow(
                       "TTY",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       NULL,
                       hInstance,
                       TRUE)))
         return FALSE;

     // subclass the stdio window

     lpfnOldTTYProc = (FARPROC) SetWindowLong(hTTYWnd,GWL_WNDPROC,
                                           (DWORD) TTYWndProc);

     // add the about box to the system menu
     AboutInit(hTTYWnd,hInstance);

     // add the terminal menu
     SetMenu(hTTYWnd,LoadMenu(hInstance, "TTYMENU"));

     // set the application icon
     SetClassWord(hTTYWnd, GCW_HICON,
                  LoadIcon( hInstance, MAKEINTRESOURCE(TTYICON) ));

     bConnected = FALSE;

     // initialize the DCB to default settings
     if(BuildCommDCB(CommSettings,&CommDCB) != 0) {
         MessageBox(GetFocus(),"Error Building DCB!","",MB_OK);
     }

     CommDCB.CtsTimeout = 100;         // Set Cts Timeout value
     CommDCB.DsrTimeout = 100;         // Set Dsr Timeout value
     CommDCB.fOutX = 1;           // output Xon/Xoff flow control on
     CommDCB.fInX = 1;           // input Xon/Xoff flow control on
     CommDCB.XonChar = 0x11;         // specify the Xon character
     CommDCB.XoffChar = 0x13;         // specify the Xoff character
     CommDCB.fNull = 1;           // strip null characters
     CommDCB.XonLim = 30;         // distance from queue empty to Xon
     CommDCB.XoffLim = (cbInBuf/2) + 1; // distance from queue full to Xoff
     CommDCB.fBinary = 0;

     // show the window
     ShowWindow( hTTYWnd, cmdShow );
     UpdateWindow( hTTYWnd );

     // PeekMessage loop to poll the comm port and pull messages from the queu
     // if there is a message available, process it.
     // otherwise, check the port and handle any available characters.

     while(TRUE){
         bMsgAvail = PeekMessage(&msg,NULL,0,0,PM_REMOVE);

         if(bMsgAvail){

             if(msg.message == WM_QUIT) break;

             TranslateMessage((LPMSG)&msg);
             DispatchMessage((LPMSG)&msg);

         } else {

             // check the comm port and process any available
             // characters. you could also use a timer instead, and have
             // the timer case of the wndproc check the port.
             if(bConnected){

                 // get the CommStat record and get the # of characters availa
     GetCommError(CommDCB.Id,&CommStat);

                 // get the number of characters available
                 iNumRead = CommStat.cbInQue;

                 if(iNumRead > 0) {

                     // get the number of characters rounded to the buffer siz
                     if(iNumRead > BufMax) iNumRead = BufMax;

                     // read the characters
                     iNumRead = ReadComm(CommDCB.Id,MsgBuff,
                                         iNumRead);

                     // check for errors
                     if(iNumRead < 0) {
                         iNumRead = -iNumRead;
                         nCommErr = GetCommError(CommDCB.Id,&CommStat);
                         // clear the event mask
       wCommEvt = GetCommEventMask(CommDCB.Id,0xFFFF);
                         // display what the error was
                         LoadString(hInst, nCommErr, sTemp, 20);
                         MessageBox(GetFocus(), sTemp, "Comm Read Error!",MB_O
                     }

                     MsgBuff[iNumRead] = '\0';

                     // send the characters to the tty window for processing
                     SendMessage(hTTYWnd,COMM_CHARS,
         iNumRead,(LONG)(LPSTR)MsgBuff);
         //wputs((LPSTR) MsgBuff);  // could just do this instead
                 }


             }
         }
     }

 }

 //========================================================================\\

 // FUNCTION: TTYWndProc(HWND, unsigned, WORD, LONG)

 // PURPOSE:  Processes messages for the terminal window.

 //========================================================================\\

 long FAR PASCAL TTYWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC   lpSettingDlgProc;
     char      szErr[22];
     unsigned  nErr;

     switch (message)
     {

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_ENDSESSION:
   if (wParam && bConnected)
       SendMessage(hWnd, WM_COMMAND, TTYCONNECT, 1L);
   break;

     case WM_CLOSE:
         // disconnect if still connected
         if(bConnected)SendMessage(hWnd,WM_COMMAND,TTYCONNECT,0L);
         // go ahead and close down
         return CallWindowProc(lpfnOldTTYProc,hWnd,
                               message,wParam,lParam);
         break;

     case WM_COMMAND:
         switch(wParam){

         case IDSABOUT:
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             break;

         case TTYEXIT:
             PostMessage(hWnd,WM_CLOSE,0,0L);
             break;

         case TTYCONNECT:
             // connect to port if not already connected
             if(!bConnected){
     if((PortID = OpenComm((CommDCB.Id == 2?COM2:COM1),cbInBuf,cbOutBuf)) < 0)
                     MessageBox(hWnd,"Error Opening Comm Port!","",MB_OK);
                     break;
                 }

                 FlushComm(PortID,0);
                 FlushComm(PortID,1);

     CommDCB.Id = PortID;
     if(CommDCB.fInX) {
         CommDCB.fOutX = 1;      // enable output Xon/Xoff flow ctl
         CommDCB.fInX = 1;      // enable input Xon/Xoff flow ctl
         CommDCB.fRtsflow = 0;   // disable hardware flow ctl
         CommDCB.fDtrflow = 0;   // disable hardware flow ctl
     } else {
         CommDCB.fOutX = 0;      // disable ouput Xon/Xoff flow ctl
         CommDCB.fInX = 0;      // disable input Xon/Xoff flow ctl
         CommDCB.fRtsflow = 1;   // enable hardware flow ctl
         CommDCB.fDtrflow = 1;   // enable hardware flow ctl
     }


                 if(SetCommState(&CommDCB) !=0 ){
                     MessageBox(hWnd,"Error Setting CommState!","",MB_OK);
                     break;
                 }
                 bConnected = TRUE;
                 CheckMenuItem(GetMenu(hWnd),TTYCONNECT,MF_CHECKED);
                 EnableMenuItem(GetMenu(hWnd),TTYSETTINGS,MF_DISABLED | MF_GRA
                 MessageBox(hWnd,"Connection was successful.","",MB_OK);

             }else{
                 // otherwise disconnect
                 FlushComm(CommDCB.Id,0);
                 FlushComm(CommDCB.Id,1);
                 CloseComm(CommDCB.Id);
     if (!lParam)
                     MessageBox(hWnd,"Connection closed.","",MB_OK);
                 bConnected = FALSE;
                 CheckMenuItem(GetMenu(hWnd),TTYCONNECT,MF_UNCHECKED);
                 EnableMenuItem(GetMenu(hWnd),TTYSETTINGS,MF_ENABLED);

             }
             break;

         case TTYSETTINGS:
             // settings dialog
             lpSettingDlgProc = MakeProcInstance(SettingDlgProc,hInst);
             DialogBox(hInst,"SETTINGSDLG",hWnd,lpSettingDlgProc);
             FreeProcInstance(lpSettingDlgProc);
             break;
         }
         break;

     case WM_CHAR:
   if(!bConnected) break;

   // if we're connected, send any keyboard characters to the port

         nCommErr = WriteComm(CommDCB.Id,(LPSTR) &wParam,1);
         if(nCommErr != 1) {
       nCommErr = GetCommError(CommDCB.Id,&CommStat);
             if(nCommErr != 0) {
     sTemp[0] = 0;
     for (nErr = 1; nErr != 0; nErr = nErr << 1) {
         if (nErr & nCommErr) {
       LoadString(hInst, nErr, szErr, 20);
       strcat(sTemp, szErr);
       strcat(sTemp, "\n");
         }
     }
     MessageBox(hWnd, sTemp, "Comm Write Error!", MB_OK);
             }
       wCommEvt = GetCommEventMask(CommDCB.Id, 0xFFFF);
         }
         break;

     case COMM_CHARS:
   // display available characters
         if(wParam > 0)
             wputs((LPSTR) lParam);

         break;

     // Pass all other messages to class's window procedure, since window
     // was subclassed
     default:
         return CallWindowProc(lpfnOldTTYProc,hWnd,
                               message,wParam,lParam);
         break;
     }
     return(0L);
 }


 WSTDIO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\TTY\WSTDIO.C

 //

 //  FILE:    WSTDIO.c

 //  PURPOSE: Contains functions for managing a standard I/O window.
 //          Provides a means for easily sending text to a window
 //          for debugging, etc.

 //  FUNCTIONS:
 //          SetupStdioDC() - Initializes DC.
 //          ResetStdioDC() - Selects former font into DC.
 //          GetStdioLine() - Returns pointer to specified line in buffer.
 //          StdioUpdate() - Scroll and update displayed text.
 //          putStdio() - Process I/O window messages.
 //          StdioPaint() - Paint procedure for I/O window.
 //          InitStdio() - Initialize values used by I/O window.
 //          stdioInit() - Define/register I/O window class.
 //          wopen() - Create a default I/O window.
 //          CreateStdioWindow() - Create a customized I/O window.
 //          wputs() - Puts a string in the I/O window.
 //          StdioWndProc() - Processes messages for the I/O window.
 //


 #include <windows.h>
 #include "wstdio.h"

 //========================================================================\\

 // Declarations

 //========================================================================\\

 #define MaxLines   25
 #define MaxLine    MaxLines - 1
 char sScrBuff[MaxLines][81];  // Array of characters on TTY
                                  // could make this heap object so can reallo
 short nFirstLine;    // Index of first line on TTY in the array
 short nLastLine;    // Index of last line on TTY in the array

 short nCurrPos;     // Current TTY line output position
 short nStdioCharWidth,
       nStdioCharHeight;   // width and height of Stdio font chars


 DWORD StdiobkRGB;                      // background color
 DWORD StdiotextRGB;                    // text color
 #define Stdio_FONT SYSTEM_FIXED_FONT   // font used for display
 HFONT hOldFont;
 HWND hWndStdio = NULL;                 // Handle to standard I/O window
 HANDLE hStdioInst;
 BOOL bStdioQuit;
 BOOL bInited = FALSE;


 //========================================================================\\

 // FUNCTION: SetupStdioDC(HWND, HDC)

 // PURPOSE:  Sets up the I/O window DC. Called at GetDC/BeginPaint time.

 //========================================================================\\

 void SetupStdioDC(HWND hWnd, HDC hDC)
 {
     RECT rClRect;

     GetClientRect(hWnd,&rClRect);

     // set origin to 25(+1 extra) lines from the bottom of the window
     SetViewportOrg(hDC,0,rClRect.bottom - ((MaxLines+1) * nStdioCharHeight));

     SetMapMode(hDC, MM_ANISOTROPIC);

     // Set the extents such that one unit horizontally or
     // vertically is one character width or height.
     SetWindowExt(hDC,1,1);

     // Set the viewport such that the last line in the buffer is
     // displayed at the bottom of the window.
     SetViewportExt(hDC,nStdioCharWidth,nStdioCharHeight);

     // Set the background mode to opaque, and select the font.
     SetBkMode(hDC,OPAQUE);
     hOldFont = SelectObject(hDC,GetStockObject(Stdio_FONT));

 }


 //========================================================================\\

 // FUNCTION: ResetStdioDC(HDC)

 // PURPOSE:  Prepare to release the DC by selecting the system font.

 //========================================================================\\

 void ResetStdioDC(HDC hDC)
 {
     SelectObject(hDC,hOldFont);
 }



 //========================================================================\\

 // FUNCTION: GetStdioLine(short)

 // PURPOSE:  Return a pointer to the specified line of the display.

 //========================================================================\\

 char *GetStdioLine(short ndx)
 {
     short pos;

     // find the first line (one past the last line since we have a
     // circular buffer). index to the desired line from there.
     pos = nLastLine + 1;
     if(pos == MaxLines) pos = 0;

     pos = pos + ndx;
     if(pos > MaxLine) pos = pos - MaxLines;

     return(sScrBuff[pos]);
 }



 //========================================================================\\

 // FUNCTION: StdioUpdate(HWND, HDC, int)

 // PURPOSE:  Scroll the window by the number of lines we have received,
 //           and display the text in the invalidated areas.

 //========================================================================\\

 void StdioUpdate(HWND hWnd, HDC hDC, int iLinesOut)
 {
     RECT rcRect;

     if(iLinesOut > 0){

          // scroll screen by number of lines received
    GetClientRect(hWnd,&rcRect);
    rcRect.bottom -= nStdioCharHeight;

    ScrollWindow(hWnd,0,-(nStdioCharHeight * iLinesOut),&rcRect,NULL);
     }

     UpdateWindow(hWnd);
 }


 //========================================================================\\

 // FUNCTION: putStdio(HWND, HDC, WORD, LPSTR)

 // PURPOSE:  Process incoming text to Stdio window.

 //========================================================================\\

 void putStdio(HWND hWnd, HDC hDC, WORD wParam, LPSTR lParam)
 {
     short i, j;
     char *sBuffer;
     RECT rClRect, rcInvalid;
     char *psLine;
     short iLinesOut = 0;    // # of lines to scroll

     sBuffer = sScrBuff[nLastLine]; // pointer to current line

     // scan the text, handle any special characters, and display the rest.

     for(i=0; i<wParam; i++){
   switch(lParam[i]) {

         case '\r': // return
             // move to the start of the line
       nCurrPos = 0;   // reset the current position in the line
             break;

         case '\n': // new line

       // "scroll" the window
       ++iLinesOut;    // increment lines to scroll
       nCurrPos = 0;   // reset the current position in the line

       ++nLastLine;
       if(nLastLine > MaxLine) nLastLine = 0;

             // clear the new line
       sBuffer = sScrBuff[nLastLine];
       for(j=0; j<80; j++) sBuffer[j] = '\0';
             break;

         case '\b': // backspace

             // move back one space
       if(nCurrPos > 0) {

     --nCurrPos;
     sBuffer[nCurrPos] = '\0';
     rcInvalid.top = MaxLine; rcInvalid.bottom = MaxLine + 1;
     rcInvalid.left = nCurrPos;
     rcInvalid.right = nCurrPos + 1;
     LPtoDP(hDC,(POINT *) &rcInvalid, 2);

     // invalidate the area so that it gets redrawn
     InvalidateRect(hWnd,&rcInvalid, TRUE);

       }
       break;

   case '\t':
       // ignore tabs for now
       break;

         default:
             //add char to buffer
       if(nCurrPos < 80){

     // put the character in the screen buffer
     sBuffer[nCurrPos] = lParam[i]; // add char to screen line

     // calculate area to invalidate
     rcInvalid.top = MaxLine; rcInvalid.bottom = MaxLine + 1;
     rcInvalid.left = nCurrPos;
     ++nCurrPos;
     rcInvalid.right = nCurrPos;

     // only need to invalidate the area if it is on the last line
     if(iLinesOut == 0) {
         LPtoDP(hDC,(POINT *) &rcInvalid, 2);
         // invalidate the area so that it gets redrawn
         InvalidateRect(hWnd,&rcInvalid, FALSE);
     }
             }
             break;
   }
   // force scroll after 2 lines. you will scroll faster if you increase
   // this, but it may not look good.

   if(iLinesOut > 2) {
       StdioUpdate(hWnd, hDC, iLinesOut);
       iLinesOut = 0;
   }
     }

     // force scroll and update at the end of each bunch of characters.
     StdioUpdate(hWnd, hDC, iLinesOut);
 }

 //========================================================================\\

 // FUNCTION: StdioPaint(HWND)

 // PURPOSE:  The I/O window paint procedure.  Draws necessary text in
 //           the window.

 //========================================================================\\

 void StdioPaint(HWND hWnd )
 {
     char *psLine;
     register int i;
     PAINTSTRUCT ps;
     HDC hDC;
     RECT rcUpdate, rcClient;
     int nVPaintBeg, nVPaintEnd, nHPaintBeg, nHPaintEnd;

     hDC = BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
     SetupStdioDC(hWnd,hDC);

     rcUpdate = ps.rcPaint;
     DPtoLP(hDC,(POINT *) &rcUpdate, 2);

     // calculate first and last lines to update
     nVPaintBeg = max (0, rcUpdate.top);
     nVPaintEnd = min (MaxLines, rcUpdate.bottom);

     // calculate the first and last columns to update
     nHPaintBeg = max (0, rcUpdate.left);
     nHPaintEnd = min (80, rcUpdate.right);

     // display the lines that need to be drawn
     for(i=nVPaintBeg; i<nVPaintEnd; i++){
   psLine = GetStdioLine(i) + nHPaintBeg;
         TextOut(hDC,
     nHPaintBeg,
                 i,
     psLine,
     strlen(psLine));
     }
     ResetStdioDC(hDC);
     EndPaint( hWnd, (LPPAINTSTRUCT)&ps );

 }


 //========================================================================\\

 // FUNCTION: InitStdio(HWND)

 // PURPOSE:  Initialize variables used by I/O window.

 //========================================================================\\

 void InitStdio(HWND hWnd)
 {
     int i,j;
     HDC hDC;
     TEXTMETRIC Metrics;

     // initialize screen buffer to nulls
     for(i=0; i<MaxLines; i++)
   for(j=0; j<81; j++)
       sScrBuff[i][j] = '\0';

     nFirstLine = 0;
     nLastLine = MaxLine;
     nCurrPos = 0;

     // get the text metrics for the font we are using
     hDC = GetDC(hWnd);
     hOldFont = SelectObject(hDC,GetStockObject(Stdio_FONT));
     GetTextMetrics(hDC,&Metrics);
     SelectObject(hDC,hOldFont);
     ReleaseDC(hWnd,hDC);

     // calculate the height and width of the font
     nStdioCharWidth = Metrics.tmMaxCharWidth;
     nStdioCharHeight = Metrics.tmHeight + Metrics.tmExternalLeading;

     // get the background and forground colors we are going to use
     StdiobkRGB = GetSysColor(COLOR_WINDOW); // background color
     StdiotextRGB = GetSysColor(COLOR_WINDOWTEXT); // text color

     bInited = TRUE;

 }


 //========================================================================\\

 // FUNCTION: stdioInit(HANDLE)

 // PURPOSE:  Initialize the stdio module. Registers the window class.

 // RETURNS:  Status of RegisterClass().

 //========================================================================\\

 BOOL stdioInit(HANDLE hInstance)
 {

     PWNDCLASS pStdioClass;
     HWND hDummyWnd;

     if(hInstance == NULL) return FALSE;

     // create the stdio window
     pStdioClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pStdioClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pStdioClass->lpszClassName  = (LPSTR)"Stdio";
     pStdioClass->hbrBackground  = COLOR_WINDOW + 1;
     pStdioClass->hInstance      = hInstance;
     pStdioClass->style    = CS_HREDRAW | CS_VREDRAW;
     pStdioClass->lpfnWndProc    = StdioWndProc;

     if (!RegisterClass( (LPWNDCLASS)pStdioClass ) )
         // Initialization failed.
         // Windows will automatically deallocate all allocated memory.
         return FALSE;

     LocalFree( (HANDLE)pStdioClass );

     hStdioInst = hInstance;
     return TRUE;
 }


 //========================================================================\\

 // FUNCTION: wopen(HWND, BOOL)

 // PURPOSE:  Create a default style stdio window. If bQuit is TRUE,
 //           PostQuitMessage will be called when the window is closed.
 //           Therefore, the stdio window can be used for the main
 //           application window.

 // RETURNS:  Handle to window created.

 //========================================================================\\

 HWND wopen(HWND hWndParent, BOOL bQuit)
 {

     // if window already created, return handle
     if(hWndStdio != NULL) return hWndStdio;

     hWndStdio = CreateWindow((LPSTR)"Stdio",
                     (LPSTR)"STDIO",
         WS_OVERLAPPEDWINDOW,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     (HWND)hWndParent,
                     (HMENU)NULL,
                     (HANDLE)hStdioInst,
                     (LPSTR)NULL
                 );
     if(hWndStdio == NULL) return FALSE;
     ShowWindow(hWndStdio, SW_SHOW);
     UpdateWindow(hWndStdio);

     bStdioQuit = bQuit;
     return hWndStdio;

 }


 //========================================================================\\

 // FUNCTION: CreateStdioWindow(LPSTR, DWORD, int, int, int, int, HWND,
 //                            HANDLE, BOOL)

 // PURPOSE:  Create an I/O window with definable name, style, size, etc.

 // RETURNS:  Handle to window created.

 //========================================================================\\

 HWND CreateStdioWindow(LPSTR lpWindowName, DWORD dwStyle,
                        int X, int Y, int nWidth, int nHeight,
                        HWND hWndParent, HANDLE hInstance, BOOL bQuit)
 {

     // if window already created, return handle
     if(hWndStdio != NULL) return hWndStdio;

     hWndStdio = CreateWindow((LPSTR)"Stdio",
                     (LPSTR)lpWindowName,
                     dwStyle,
                     X,
                     Y,
                     nWidth,
                     nHeight,
                     (HWND)hWndParent,
                     (HMENU)NULL,
                     (HANDLE)hInstance,
                     (LPSTR)NULL);

     if(hWndStdio == NULL) return FALSE;

     bStdioQuit = bQuit;
     return hWndStdio;
 }


 //========================================================================\\

 // FUNCTION: wputs(LPSTR)

 // PURPOSE:  Equivalent to puts() stdio function. Currently, '\n' is
 //           not recognized as in '\r\n', as with normal puts(). Must
 //           send '\r\n' explicitly.

 // RETURNS:  Status of wopen(), if called, otherwise TRUE.

 //========================================================================\\


 BOOL wputs(LPSTR lpStr)
 {
     HDC hDC;
     int nStrLen;

     // if being used for quick and dirty text output, a stdio window
     // will be opened if it hasn't been already.
     if(hWndStdio == NULL) if(wopen(NULL, FALSE) == NULL) return FALSE;

     hDC = GetDC(hWndStdio);
     SetupStdioDC(hWndStdio,hDC);
     nStrLen = lstrlen(lpStr);

     putStdio(hWndStdio,hDC,nStrLen,(LPSTR)lpStr);

     ResetStdioDC(hDC);
     ReleaseDC(hWndStdio,hDC);

     return TRUE;
 }


 //========================================================================\\

 // FUNCTION: StdioWndProc(HWND, unsigned, WORD, LONG)

 // PURPOSE:  Process messages for the I/O window. This function should
 //           be exported in the application's .DEF file.

 //========================================================================\\

 long FAR PASCAL StdioWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;
     HDC hDC;
     LPPOINT ptMinMaxInfo;


     switch (message)
     {

     case WM_CREATE:

   // initialize stdio variables
   InitStdio(hWnd);
   break;


     case WM_SYSCOLORCHANGE:

   // if the colors have been changed in the control panel,
   // we need to change also.

   StdiobkRGB = GetSysColor(COLOR_WINDOW); // background color
   StdiotextRGB = GetSysColor(COLOR_WINDOWTEXT); // text color
         return DefWindowProc( hWnd, message, wParam, lParam );
   break;

     case WM_GETMINMAXINFO:
   if(!bInited) InitStdio(hWnd);

   // constrain the sizing of the window to 80 by 25 characters.

   ptMinMaxInfo = (LPPOINT) lParam;

   ptMinMaxInfo[1].x = nStdioCharWidth * 80
            + 2 * GetSystemMetrics(SM_CXFRAME);
   ptMinMaxInfo[1].y = nStdioCharHeight * 26
            + 2 * GetSystemMetrics(SM_CYFRAME);

   ptMinMaxInfo[4].x = nStdioCharWidth * 80
            + 2 * GetSystemMetrics(SM_CXFRAME);
   ptMinMaxInfo[4].y = nStdioCharHeight * 26
            + 2 * GetSystemMetrics(SM_CYFRAME);
   break;

     case WM_PAINT:

   // repaint the Stdio window
   StdioPaint(hWnd);
   break;

     case WM_DESTROY:

   // if specified when created, PostQuitMessage should be called
   // when the window is destroyed.

         if(bStdioQuit)
             PostQuitMessage(0);
         break;

     case WM_CLOSE:
         // destroy stdio data
         hWndStdio = NULL;

         // go ahead and close down
         // -- fall through to default --
     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }




 Microsoft Windows S.D.K. v3.0 Sample MASM Source Code


 CLOCKDAT.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\CLOCK\CLOCKDAT.ASM

         title   Hardware Dependent Parameters
         %out    config
         page    ,132
 OEM     segment public
 dw         0,     -7999
 dw         836,   -7956
 dw         1663,  -7825
 dw         2472,  -7608
 dw         3253,  -7308
 dw         3999,  -6928
 dw         4702,  -6472
 dw         5353,  -5945
 dw         5945,  -5353
 dw         6472,  -4702
 dw         6928,  -4000
 dw         7308,  -3253
 dw         7608,  -2472
 dw         7825,  -1663
 dw         7956,  -836

 dw         8000,  0
 dw         7956,  836
 dw         7825,  1663
 dw         7608,  2472
 dw         7308,  3253
 dw         6928,  4000
 dw         6472,  4702
 dw         5945,  5353
 dw         5353,  5945
 dw         4702,  6472
 dw         3999,  6928
 dw         3253,  7308
 dw         2472,  7608
 dw         1663,  7825
 dw         836,   7956

 dw          0,    7999
 dw         -836,  7956
 dw         -1663, 7825
 dw         -2472, 7608
 dw         -3253, 7308
 dw         -4000, 6928
 dw         -4702, 6472
 dw         -5353, 5945
 dw         -5945, 5353
 dw         -6472, 4702
 dw         -6928, 3999
 dw         -7308, 3253
 dw         -7608, 2472
 dw         -7825, 1663
 dw         -7956, 836

 dw         -7999, -0
 dw         -7956, -836
 dw         -7825, -1663
 dw         -7608, -2472
 dw         -7308, -3253
 dw         -6928, -4000
 dw         -6472, -4702
 dw         -5945, -5353
 dw         -5353, -5945
 dw         -4702, -6472
 dw         -3999, -6928
 dw         -3253, -7308
 dw         -2472, -7608
 dw         -1663, -7825
 dw         -836 , -7956
 OEM     ends
 end



 DLGOPENA.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SHOWDIB\DLGOPENA.ASM

   title  dlgopena.asm
 ;****************************************************************************
 ;*                         *
 ;*  MODULE  : DLGOPENA.ASM                   *
 ;*                         *
 ;*  DESCRIPTION : Assembly language helper routines for DLGOPEN.C         *
 ;*                         *
 ;*  FUNCTIONS  : chdir ()  - change to specified asciiz directory.         *
 ;*                         *
 ;****************************************************************************
 ?WIN = 1

 ?PLM=1      ; PASCAL Calling convention is DEFAULT
 ?WIN=1      ; Windows calling convention
 ?386=0      ; Use 386 code?
 include cmacros.inc

 ;*********************************************************************
 ;* The following structure should be used to access high and low
 ;* words of a DWORD.  This means that "word ptr foo[2]" -> "foo.hi".
 ;*********************************************************************

 LONG    struc
 lo      dw      ?
 hi      dw      ?
 LONG    ends

 FARPOINTER      struc
 off     dw      ?
 sel     dw      ?
 FARPOINTER      ends

 ;*********************************************************************
 ;               DATA SEGMENT DECLARATIONS
 ;*********************************************************************

 ifndef SEGNAME
     SEGNAME equ <TEXT>
 endif

 if ?386
     .386p
     createSeg _%SEGNAME, CodeSeg, word, use16, CODE
 else
     .286p
     createSeg _%SEGNAME, CodeSeg, word, public, CODE
 endif

 sBegin  DATA
 sEnd  DATA

 sBegin  CodeSeg

 assumes CS,CodeSeg
 assumes DS,DATA

 ;****************************************************************************
 ;*                      *
 ;*  FUNCTION   : chdir (p)                *
 ;*                      *
 ;*  PURPOSE    : Change to asciiz directory specified in p        *
 ;*                      *
 ;*  RETURNS    : 1 - Success                *
 ;*     0 - Error                *
 ;*                      *
 ;****************************************************************************

 cProc  chdir,<PUBLIC,FAR,PASCAL>,<ds>
   parmD p
 cBegin
   lds  dx,p
   mov  bx,dx

   cmp  BYTE PTR ds:[bx+1],':'
         jnz     chdnod                  ; No drive
         mov     dl,ds:[bx]
         or      dl,20h
         sub     dl,'a'

   mov  ah,0eh      ; Set current drive
   int  21h

   mov  ah,19h      ; Get current drive
   int  21h

   cmp  al,dl
   jne  chderror

   lds  dx,p
   add  dx,2
   mov  bx,dx
   cmp  BYTE PTR ds:[bx],0  ; If path name is "" we are there
   jz  chdok
 chdnod:
   mov  ah,3bh
   int  21h
   jc  chderror
 chdok:
   mov  ax,1
 chdexit:
 cEnd
 chderror:
   xor  ax,ax
   jmp  short chdexit

 sEnd  CodeSeg

 end


 GETTIME.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\CLOCK\GETTIME.ASM

 ; get the time more efficiently than cmerge and DOSCALL() do

 ?PLM=0
 include cmacros.inc

 time    struc
         hour    dw  ?
         minute  dw  ?
         second  dw  ?
 time    ends

 assumes CS,CODE
 assumes DS,DATA

 sBegin   CODE

 cProc   GetTime, <PUBLIC, NEAR>
         parmW   pTime               ; pointer to the structure to fill

 cBegin
         mov     ax, 2c00h           ; get time
         int     21h
         mov     bx, pTime
         cmp     ch, 12                  ; if hour <12
         jl      lt12                    ; we're ok
         sub     ch,12                   ; else adjust it
 lt12:
         xor     ax,ax
         mov     al,ch
         mov     [bx].hour, ax
         mov     al,cl
         mov     [bx].minute, ax
         mov     al,dh
         mov     [bx].second, ax
 cEnd
 sEnd    CODE
         END


 LIBENTRY.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\SELECT\LIBENTRY.ASM

 PAGE,132
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ;       LIBENTRY.ASM
 ;
 ;       Windows dynamic link library entry routine
 ;
 ;   This module generates a code segment called INIT_TEXT.
 ;   It initializes the local heap if one exists and then calls
 ;   the C routine LibMain() which should have the form:
 ;   BOOL FAR PASCAL LibMain(HANDLE hInstance,
 ;                           WORD   wDataSeg,
 ;                           WORD   cbHeap,
 ;                           LPSTR  lpszCmdLine);
 ;
 ;   The result of the call to LibMain is returned to Windows.
 ;   The C routine should return TRUE if it completes initialization
 ;   successfully, FALSE if some error occurs.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 include cmacros.inc

 externFP <LibMain>               ; the C routine to be called

 createSeg INIT_TEXT, INIT_TEXT, BYTE, PUBLIC, CODE
 sBegin  INIT_TEXT
 assumes CS,INIT_TEXT

 ?PLM=0                           ; 'C'naming
 externA  <_acrtused>             ; ensures that Win DLL startup code is linke

 ?PLM=1                           ; 'PASCAL' naming
 externFP <LocalInit>             ; Windows heap init routine

 cProc   LibEntry, <PUBLIC,FAR>   ; entry point into DLL

 cBegin
         push    di               ; handle of the module instance
         push    ds               ; library data segment
         push    cx               ; heap size
         push    es               ; command line segment
         push    si               ; command line offset

         ; if we have some heap then initialize it
         jcxz    callc            ; jump if no heap specified

         ; call the Windows function LocalInit() to set up the heap
         ; LocalInit((LPSTR)start, WORD cbHeap);

         xor     ax,ax
         cCall   LocalInit <ds, ax, cx>
         or      ax,ax            ; did it do it ok ?
         jz      error            ; quit if it failed

         ; invoke the C routine to do any special initialization

 callc:
         call    LibMain          ; invoke the 'C' routine (result in AX)
         jmp short exit           ; LibMain is responsible for stack clean up

 error:
   pop  si     ; clean up stack on a LocalInit error
         pop     es
         pop     cx
         pop     ds
         pop     di

 exit:

 cEnd

 sEnd  INIT_TEXT

 end LibEntry


 LIBENTRY.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_SDK\RAINBOW\LIBENTRY.ASM

 PAGE,132
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ;       LIBENTRY.ASM
 ;
 ;       Windows dynamic link library entry routine
 ;
 ;   This module generates a code segment called INIT_TEXT.
 ;   It initializes the local heap if one exists and then calls
 ;   the C routine LibMain() which should have the form:
 ;   BOOL FAR PASCAL LibMain(HANDLE hInstance,
 ;                           WORD   wDataSeg,
 ;                           WORD   cbHeap,
 ;                           LPSTR  lpszCmdLine);
 ;
 ;   The result of the call to LibMain is returned to Windows.
 ;   The C routine should return TRUE if it completes initialization
 ;   successfully, FALSE if some error occurs.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 include cmacros.inc

 externFP <LibMain>               ; the C routine to be called

 createSeg INIT_TEXT, INIT_TEXT, BYTE, PUBLIC, CODE
 sBegin  INIT_TEXT
 assumes CS,INIT_TEXT

 ?PLM=0                           ; 'C'naming
 externA  <_acrtused>             ; ensures that Win DLL startup code is linke

 ?PLM=1                           ; 'PASCAL' naming
 externFP <LocalInit>             ; Windows heap init routine

 cProc   LibEntry, <PUBLIC,FAR>   ; entry point into DLL

 cBegin
         push    di               ; handle of the module instance
         push    ds               ; library data segment
         push    cx               ; heap size
         push    es               ; command line segment
         push    si               ; command line offset

         ; if we have some heap then initialize it
         jcxz    callc            ; jump if no heap specified

         ; call the Windows function LocalInit() to set up the heap
         ; LocalInit((LPSTR)start, WORD cbHeap);

         xor     ax,ax
         cCall   LocalInit <ds, ax, cx>
         or      ax,ax            ; did it do it ok ?
         jz      error            ; quit if it failed

         ; invoke the C routine to do any special initialization

 callc:
         call    LibMain          ; invoke the 'C' routine (result in AX)
         jmp short exit           ; LibMain is responsible for stack clean up

 error:
   pop  si     ; clean up stack on a LocalInit error
         pop     es
         pop     cx
         pop     ds
         pop     di

 exit:

 cEnd

 sEnd  INIT_TEXT

 end LibEntry




 Programming Windows (C. Petzold) Sample `C' Source Code


 ABOUT1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\ABOUT1.C

 /*------------------------------------------
    ABOUT1.C -- About Box Demo Program No. 1
          (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>
 #include "about1.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
         LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "About1" ;
      MSG         msg;
      HWND        hwnd ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "About Box Demo Program",
                           WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL AboutDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                return TRUE ;

           case WM_COMMAND:
                switch (wParam)
                     {
         case IDOK:
         case IDCANCEL:
                          EndDialog (hDlg, 0) ;
        return TRUE ;
                     }
                break ;
           }
      return FALSE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpfnAboutDlgProc ;
      static HANDLE  hInstance ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

                lpfnAboutDlgProc = MakeProcInstance (AboutDlgProc, hInstance)
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_ABOUT:
                          DialogBox (hInstance, "AboutBox", hwnd,
                                         lpfnAboutDlgProc) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 ABOUT2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\ABOUT2.C

 /*------------------------------------------
    ABOUT2.C -- About Box Demo Program No. 2
                (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>
 #include "about2.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 short nCurrentColor  = IDD_BLACK,
       nCurrentFigure = IDD_RECT ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "About2" ;
      MSG         msg;
      HWND        hwnd ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "About Box Demo Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void PaintWindow (HWND hwnd, short nColor, short nFigure)
      {
      static DWORD dwColor [8] = { RGB (0,     0, 0), RGB (  0,   0, 255),
                                   RGB (0,   255, 0), RGB (  0, 255, 255),
                                   RGB (255,   0, 0), RGB (255,   0, 255),
                                   RGB (255, 255, 0), RGB (255, 255, 255) } ;
      HBRUSH       hBrush ;
      HDC          hdc ;
      RECT         rect ;

      hdc = GetDC (hwnd) ;
      GetClientRect (hwnd, &rect) ;
      hBrush = CreateSolidBrush (dwColor [nColor - IDD_BLACK]) ;
      hBrush = SelectObject (hdc, hBrush) ;

      if (nFigure == IDD_RECT)
           Rectangle (hdc, rect.left, rect.top, rect.right, rect.bottom) ;
      else
           Ellipse   (hdc, rect.left, rect.top, rect.right, rect.bottom) ;

      DeleteObject (SelectObject (hdc, hBrush)) ;
      ReleaseDC (hwnd, hdc) ;
      }

 void PaintTheBlock (HWND hCtrl, short nColor, short nFigure)
      {
      InvalidateRect (hCtrl, NULL, TRUE) ;
      UpdateWindow (hCtrl) ;
      PaintWindow (hCtrl, nColor, nFigure) ;
      }

 BOOL FAR PASCAL AboutDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      static HWND  hCtrlBlock ;
      static short nColor, nFigure ;

      switch (message)
           {
           case WM_INITDIALOG:
                nColor  = nCurrentColor ;
                nFigure = nCurrentFigure ;

                CheckRadioButton (hDlg, IDD_BLACK, IDD_WHITE, nColor) ;
                CheckRadioButton (hDlg, IDD_RECT,  IDD_ELL,   nFigure) ;

                hCtrlBlock = GetDlgItem (hDlg, IDD_PAINT) ;

                SetFocus (GetDlgItem (hDlg, nColor)) ;
                return FALSE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDOK:
                          nCurrentColor  = nColor ;
                          nCurrentFigure = nFigure ;
                          EndDialog (hDlg, TRUE) ;
                          return TRUE ;

                     case IDCANCEL:
                          EndDialog (hDlg, FALSE) ;
                          return TRUE ;

                     case IDD_BLACK:
                     case IDD_RED:
                     case IDD_GREEN:
                     case IDD_YELLOW:
                     case IDD_BLUE:
                     case IDD_MAGENTA:
                     case IDD_CYAN:
                     case IDD_WHITE:
                          nColor = wParam ;
                          CheckRadioButton (hDlg, IDD_BLACK, IDD_WHITE, wParam
                          PaintTheBlock (hCtrlBlock, nColor, nFigure) ;
                          return TRUE ;

                     case IDD_RECT:
                     case IDD_ELL:
                          nFigure = wParam ;
                          CheckRadioButton (hDlg, IDD_RECT, IDD_ELL, wParam) ;
                          PaintTheBlock (hCtrlBlock, nColor, nFigure) ;
                          return TRUE ;
                     }
                break ;

           case WM_PAINT:
                PaintTheBlock (hCtrlBlock, nColor, nFigure) ;
                break ;
           }
      return FALSE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpfnAboutDlgProc ;
      static HANDLE  hInstance ;
      PAINTSTRUCT    ps ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

                lpfnAboutDlgProc = MakeProcInstance (AboutDlgProc, hInstance)
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_ABOUT:
                          if (DialogBox (hInstance, "AboutBox", hwnd,
                                         lpfnAboutDlgProc))
                               InvalidateRect (hwnd, NULL, TRUE) ;
                          return 0 ;
                     }
                break ;

           case WM_PAINT:
                BeginPaint (hwnd, &ps) ;
                EndPaint (hwnd, &ps) ;

                PaintWindow (hwnd, nCurrentColor, nCurrentFigure) ;
                return 0 ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 ABOUT3.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\ABOUT3.C

 /*------------------------------------------
    ABOUT3.C -- About Box Demo Program No. 3
                (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>
 #include "about3.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL EllipPushWndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "About3" ;
      MSG         msg;
      HWND        hwnd ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = EllipPushWndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = COLOR_WINDOW + 1 ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = "EllipPush" ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "About Box Demo Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL AboutDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                return TRUE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDOK:
                          EndDialog (hDlg, 0) ;
                          return TRUE ;
                     }
                break ;
           }
      return FALSE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpfnAboutDlgProc ;
      static HANDLE  hInstance ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

                lpfnAboutDlgProc = MakeProcInstance (AboutDlgProc, hInstance)
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_ABOUT:
                          DialogBox (hInstance, "AboutBox", hwnd,
                                         lpfnAboutDlgProc) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL EllipPushWndProc (HWND hwnd, WORD message,
                                   WORD wParam, LONG lParam)
      {
      char        szText [40] ;
      HBRUSH      hBrush ;
      HDC         hdc ;
      PAINTSTRUCT ps ;
      RECT        rect ;

      switch (message)
           {
           case WM_PAINT:
                GetClientRect (hwnd, &rect) ;
                GetWindowText (hwnd, szText, sizeof szText) ;

                hdc = BeginPaint (hwnd, &ps) ;

                hBrush = CreateSolidBrush (GetSysColor (COLOR_WINDOW)) ;
                hBrush = SelectObject (hdc, hBrush) ;
                SetBkColor (hdc, GetSysColor (COLOR_WINDOW)) ;
                SetTextColor (hdc, GetSysColor (COLOR_WINDOWTEXT)) ;

                Ellipse (hdc, rect.left, rect.top, rect.right, rect.bottom) ;
                DrawText (hdc, szText, -1, &rect,
                               DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;

                DeleteObject (SelectObject (hdc, hBrush)) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_KEYUP:
                if (wParam != VK_SPACE)
                     break ;
                                         // fall through
           case WM_LBUTTONUP:
                SendMessage (GetParent (hwnd), WM_COMMAND,
                     GetWindowWord (hwnd, GWW_ID), (LONG) hwnd) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 ARCS.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP12\ARCS.C

 /*-------------------------------------------------------
    ARCS.C -- Demonstrates Drawing Arcs, Chords, and Pies
              (c) Charles Petzold, 1990
   -------------------------------------------------------*/

 #include <windows.h>
 #include "arcs.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Arcs" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Arcs, Chords, and Pies",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short cxClient, cyClient, x1, x2, x3, x4, y1, y2, y3, y4,
                   nFigure = IDM_ARC ;
      HDC          hdc ;
      HMENU        hMenu ;
      HPEN         hPen ;
      PAINTSTRUCT  ps ;
      short        x, y ;

      switch (message)
           {
           case WM_SIZE:
                x3 = y3 = 0 ;
                x4 = cxClient = LOWORD (lParam) ;
                y4 = cyClient = HIWORD (lParam) ;
                x2 = 3 * (x1 = cxClient / 4) ;
                y2 = 3 * (y1 = cyClient / 4) ;
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_ARC:
                     case IDM_CHORD:
                     case IDM_PIE:
                          hMenu = GetMenu (hwnd) ;
                          CheckMenuItem (hMenu, nFigure, MF_UNCHECKED) ;
                          CheckMenuItem (hMenu, nFigure = wParam, MF_CHECKED)
                          InvalidateRect (hwnd, NULL, FALSE) ;
                          return 0 ;
                     }
                break ;

           case WM_LBUTTONDOWN:
                if (!(wParam & MK_SHIFT))
                     {
                     x3 = LOWORD (lParam) ;
                     y3 = HIWORD (lParam) ;
                     InvalidateRect (hwnd, NULL, TRUE) ;
                     return 0 ;
                     }
                                         // fall through for MK_SHIFT
           case WM_RBUTTONDOWN:
                x4 = LOWORD (lParam) ;
                y4 = HIWORD (lParam) ;
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                hPen = SelectObject (hdc, CreatePen (PS_DOT, 1, 0L)) ;
                Rectangle (hdc, x1, y1, x2, y2) ;
                Ellipse   (hdc, x1, y1, x2, y2) ;

                DeleteObject (SelectObject (hdc, CreatePen (PS_SOLID, 3, 0L)))

                switch (nFigure)
                     {
                     case IDM_ARC:
                          Arc (hdc, x1, y1, x2, y2, x3, y3, x4, y4) ;
                          break ;

                     case IDM_CHORD:
                          Chord (hdc, x1, y1, x2, y2, x3, y3, x4, y4) ;
                          break ;

                     case IDM_PIE:
                          Pie (hdc, x1, y1, x2, y2, x3, y3, x4, y4) ;
                          break ;
                     }

                DeleteObject (SelectObject (hdc, hPen)) ;

                MoveTo (hdc, x3, y3) ;
                LineTo (hdc, cxClient / 2, cyClient / 2) ;
                LineTo (hdc, x4, y4) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 BEEPER1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP05\BEEPER1.C

 /*-----------------------------------------
    BEEPER1.C  -- Timer Demo Program No. 1
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #define ID_TIMER    1

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Beeper1" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Beeper1 Timer Demo",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      while (!SetTimer (hwnd, ID_TIMER, 1000, NULL))
           if (IDCANCEL == MessageBox (hwnd,
                               "Too many clocks or timers!", szAppName,
                               MB_ICONEXCLAMATION | MB_RETRYCANCEL))
                return FALSE ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL fFlipFlop = FALSE ;
      HBRUSH      hBrush ;
      HDC         hdc ;
      PAINTSTRUCT ps ;
      RECT        rc ;

      switch (message)
           {
           case WM_TIMER:
                MessageBeep (0) ;

                fFlipFlop = !fFlipFlop ;
                InvalidateRect (hwnd, NULL, FALSE) ;

                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                GetClientRect (hwnd, &rc) ;

                hBrush = CreateSolidBrush (fFlipFlop ? RGB(255,0,0) :
                                                       RGB(0,0,255)) ;
                FillRect (hdc, &rc, hBrush) ;
                EndPaint (hwnd, &ps) ;
                DeleteObject (hBrush) ;
                return 0 ;

           case WM_DESTROY:
                KillTimer (hwnd, ID_TIMER) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 BEEPER2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP05\BEEPER2.C

 /*----------------------------------------
    BEEPER2.C -- Timer Demo Program No. 2
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #define ID_TIMER    1

 long FAR PASCAL WndProc   (HWND, WORD, WORD, LONG) ;
 WORD FAR PASCAL TimerProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Beeper2" ;
      FARPROC     lpfnTimerProc ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Beeper2 Timer Demo",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      lpfnTimerProc = MakeProcInstance (TimerProc, hInstance) ;

      while (!SetTimer (hwnd, ID_TIMER, 1000, lpfnTimerProc))
           if (IDCANCEL == MessageBox (hwnd,
                               "Too many clocks or timers!", szAppName,
                               MB_ICONEXCLAMATION | MB_RETRYCANCEL))
                return FALSE ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_DESTROY:
                KillTimer (hwnd, ID_TIMER) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 WORD FAR PASCAL TimerProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL fFlipFlop = FALSE ;
      HBRUSH      hBrush ;
      HDC         hdc ;
      RECT        rc ;

      MessageBeep (0) ;
      fFlipFlop = !fFlipFlop ;

      GetClientRect (hwnd, &rc) ;

      hdc = GetDC (hwnd) ;
      hBrush = CreateSolidBrush (fFlipFlop ? RGB(255,0,0) : RGB(0,0,255)) ;

      FillRect (hdc, &rc, hBrush) ;
      ReleaseDC (hwnd, hdc) ;
      DeleteObject (hBrush) ;

      return 0 ;
      }


 BITLIB.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP19\BITLIB.C

 /*--------------------------------------------------------------
    BITLIB.C -- Code entry point for BITLIB dynamic link library
                (c) Charles Petzold,  1990
   --------------------------------------------------------------*/
 #include <windows.h>

 int FAR PASCAL LibMain (HANDLE hInstance, WORD wDataSeg, WORD wHeapSize,
                         LPSTR lpszCmdLine)
      {
      if (wHeapSize > 0)
           UnlockData (0) ;

      return 1 ;
      }


 BLOWUP1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP04\BLOWUP1.C

 /*------------------------------------------------
    BLOWUP1.C -- Screen Capture Mouse Demo Program
                (c) Charles Petzold, 1990
   ------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "BlowUp1" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Blow-Up Mouse Demo",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void InvertBlock (HWND hwnd, POINT ptBeg, POINT ptEnd)
      {
      HDC hdc ;

      hdc = CreateDC ("DISPLAY", NULL, NULL, NULL) ;
      ClientToScreen (hwnd, &ptBeg) ;
      ClientToScreen (hwnd, &ptEnd) ;
      PatBlt (hdc, ptBeg.x, ptBeg.y, ptEnd.x - ptBeg.x, ptEnd.y - ptBeg.y,
              DSTINVERT) ;
      DeleteDC (hdc) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL  fCapturing, fBlocking ;
      static POINT ptBeg, ptEnd ;
      HDC          hdc ;
      RECT         rect ;

      switch (message)
           {
           case WM_LBUTTONDOWN:
                if (!fCapturing)
                     {
                     fCapturing = TRUE ;
                     SetCapture (hwnd) ;
                     SetCursor (LoadCursor (NULL, IDC_CROSS)) ;
                     }
                else if (!fBlocking)
                     {
                     fBlocking = TRUE ;
                     ptBeg = MAKEPOINT (lParam) ;
                     }
                return 0 ;

           case WM_MOUSEMOVE:
                if (fBlocking)
                     {
                     ptEnd = MAKEPOINT (lParam) ;
                     InvertBlock (hwnd, ptBeg, ptEnd) ;
                     InvertBlock (hwnd, ptBeg, ptEnd) ;
                     }
                return 0 ;

           case WM_LBUTTONUP:
                if (fBlocking)
                     {
                     fCapturing = fBlocking = FALSE ;
                     ptEnd = MAKEPOINT (lParam) ;
                     SetCursor (LoadCursor (NULL, IDC_WAIT)) ;

                     hdc = GetDC (hwnd) ;
                     GetClientRect (hwnd, &rect) ;
                     StretchBlt (hdc, 0, 0, rect.right, rect.bottom,
                                 hdc, ptBeg.x, ptBeg.y,
                                 ptEnd.x - ptBeg.x, ptEnd.y - ptBeg.y,
                                 SRCCOPY) ;

                     ReleaseDC (hwnd, hdc) ;
                     SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
                     ReleaseCapture () ;
                     }
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 BLOWUP2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP16\BLOWUP2.C

 /*------------------------------------------------
    BLOWUP2.C -- Capture Screen Image to Clipboard
                 (c) Charles Petzold, 1990
   ------------------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "Blowup2" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, szAppName,
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void InvertBlock (HWND hwnd, POINT org, POINT len)
      {
      HDC   hdc ;

      hdc = CreateDC ("DISPLAY", NULL, NULL, NULL) ;
      ClientToScreen (hwnd, &org) ;
      PatBlt (hdc, org.x, org.y, len.x, len.y, DSTINVERT) ;
      DeleteDC (hdc) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL  bCapturing, bBlocking ;
      static POINT org, len ;
      static short cxClient, cyClient ;
      BITMAP       bm ;
      HDC          hdc, hdcMem ;
      HBITMAP      hBitmap ;
      PAINTSTRUCT  ps ;

      switch (message)
           {
           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_LBUTTONDOWN:
                if (!bCapturing)
                     {
                     bCapturing = TRUE ;
                     SetCapture (hwnd) ;
                     SetCursor (LoadCursor (NULL, IDC_CROSS)) ;
                     }
                else if (!bBlocking)
                     {
                     bBlocking = TRUE ;
                     org = MAKEPOINT (lParam) ;
                     }
                return 0 ;

           case WM_MOUSEMOVE:
                if (bCapturing)
                     SetCursor (LoadCursor (NULL, IDC_CROSS)) ;

                if (bBlocking)
                     {
                     len = MAKEPOINT (lParam) ;
                     len.x -= org.x ;
                     len.y -= org.y ;

                     InvertBlock (hwnd, org, len) ;
                     InvertBlock (hwnd, org, len) ;
                     }
                return 0 ;

           case WM_LBUTTONUP:
                if (!bBlocking)
                     break ;

                bCapturing = bBlocking = FALSE ;
                SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
                ReleaseCapture () ;

                if (len.x == 0 || len.y == 0)
                     break ;

                hdc = GetDC (hwnd) ;
                hdcMem = CreateCompatibleDC (hdc) ;
                hBitmap = CreateCompatibleBitmap (hdc,
                                     abs (len.x), abs (len.y)) ;
                if (hBitmap)
                     {
                     SelectObject (hdcMem, hBitmap) ;
                     StretchBlt (hdcMem, 0, 0, abs (len.x), abs (len.y),
                          hdc, org.x, org.y, len.x, len.y, SRCCOPY) ;

                     OpenClipboard (hwnd) ;
                     EmptyClipboard () ;
                     SetClipboardData (CF_BITMAP, hBitmap) ;
                     CloseClipboard () ;

                     InvalidateRect (hwnd, NULL, TRUE) ;
                     }
                else
                     MessageBeep (0) ;

                DeleteDC (hdcMem) ;
                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_PAINT:
                InvalidateRect (hwnd, NULL, TRUE) ;
                hdc = BeginPaint (hwnd, &ps) ;
                OpenClipboard (hwnd) ;

                if (hBitmap = GetClipboardData (CF_BITMAP))
                     {
                     SetCursor (LoadCursor (NULL, IDC_WAIT)) ;

                     hdcMem = CreateCompatibleDC (hdc) ;
                     SelectObject (hdcMem, hBitmap) ;
                     GetObject (hBitmap, sizeof (BITMAP), (LPSTR) &bm) ;

                     SetStretchBltMode (hdc, COLORONCOLOR) ;
                     StretchBlt (hdc, 0, 0, cxClient, cyClient,
                                 hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
                                                   SRCCOPY) ;

                     SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
                     DeleteDC (hdcMem) ;
                     }

                CloseClipboard () ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 BOUNCE.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP13\BOUNCE.C

 /*---------------------------------------
    BOUNCE.C -- Bouncing Ball Program
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "Bounce" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Bouncing Ball",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      if (!SetTimer (hwnd, 1, 50, NULL))
           {
           MessageBox (hwnd, "Too many clocks or timers!",
                       szAppName, MB_ICONEXCLAMATION | MB_OK) ;
           return FALSE ;
           }

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HANDLE hBitmap ;
      static short  cxClient, cyClient, xCenter, yCenter, cxTotal, cyTotal,
                    cxRadius, cyRadius, cxMove, cyMove, xPixel, yPixel ;
      HBRUSH        hBrush ;
      HDC           hdc, hdcMem ;
      short         nScale ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                xPixel = GetDeviceCaps (hdc, ASPECTX) ;
                yPixel = GetDeviceCaps (hdc, ASPECTY) ;
                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_SIZE:
                xCenter = (cxClient = LOWORD (lParam)) / 2 ;
                yCenter = (cyClient = HIWORD (lParam)) / 2 ;

                nScale = min (cxClient * xPixel, cyClient * yPixel) / 16 ;

                cxRadius = nScale / xPixel ;
                cyRadius = nScale / yPixel ;

                cxMove = max (1, cxRadius / 4) ;
                cyMove = max (1, cyRadius / 4) ;

                cxTotal = 2 * (cxRadius + cxMove) ;
                cyTotal = 2 * (cyRadius + cyMove) ;

                if (hBitmap)
                     DeleteObject (hBitmap) ;

                hdc = GetDC (hwnd) ;
                hdcMem = CreateCompatibleDC (hdc) ;
                hBitmap = CreateCompatibleBitmap (hdc, cxTotal, cyTotal) ;
                ReleaseDC (hwnd, hdc) ;

                SelectObject (hdcMem, hBitmap) ;
                Rectangle (hdcMem, -1, -1, cxTotal + 1, cyTotal + 1) ;

                hBrush = CreateHatchBrush (HS_DIAGCROSS, 0L) ;
                SelectObject (hdcMem, hBrush) ;
                SetBkColor (hdcMem, RGB (255, 0, 255)) ;
                Ellipse (hdcMem, cxMove, cyMove, cxTotal - cxMove,
                                                 cyTotal - cyMove) ;
                DeleteDC (hdcMem) ;
                DeleteObject (hBrush) ;
                return 0 ;

           case WM_TIMER:
                if (!hBitmap)
                     break ;

                hdc = GetDC (hwnd) ;
                hdcMem = CreateCompatibleDC (hdc) ;
                SelectObject (hdcMem, hBitmap) ;

                BitBlt (hdc, xCenter - cxTotal / 2,
                             yCenter - cyTotal / 2, cxTotal, cyTotal,
                        hdcMem, 0, 0, SRCCOPY) ;

                ReleaseDC (hwnd, hdc) ;
                DeleteDC (hdcMem) ;

                xCenter += cxMove ;
                yCenter += cyMove ;

                if ((xCenter + cxRadius >= cxClient) ||
                    (xCenter - cxRadius <= 0))
                          cxMove = -cxMove ;

                if ((yCenter + cyRadius >= cyClient) ||
                    (yCenter - cyRadius <= 0))
                          cyMove = -cyMove ;
                return 0 ;

           case WM_DESTROY:
                if (hBitmap)
                     DeleteObject (hBitmap) ;

                KillTimer (hwnd, 1) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 BTNLOOK.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP06\BTNLOOK.C

 /*----------------------------------------
    BTNLOOK.C -- Button Look Program
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <stdio.h>

 struct
      {
      long style ;
      char *text ;
      }
      button[] =
      {
      BS_PUSHBUTTON,      "PUSHBUTTON",
      BS_DEFPUSHBUTTON,   "DEFPUSHBUTTON",
      BS_CHECKBOX,        "CHECKBOX",
      BS_AUTOCHECKBOX,    "AUTOCHECKBOX",
      BS_RADIOBUTTON,     "RADIOBUTTON",
      BS_3STATE,          "3STATE",
      BS_AUTO3STATE,      "AUTO3STATE",
      BS_GROUPBOX,        "GROUPBOX",
      BS_USERBUTTON,      "USERBUTTON",
      BS_AUTORADIOBUTTON, "AUTORADIO",
      BS_PUSHBOX,         "PUSHBOX"
      } ;

 #define NUM (sizeof button / sizeof button [0])

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "BtnLook" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Button Look",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char  szPrm []    = "wParam       LOWORD(lParam)  HIWORD(lParam)"
                   szTop []    = "Control ID   Window Handle   Notification",
                   szUnd []    = "__________   _____________   ____________",
                   szFormat [] = " %5u           %4X          %5u",
                   szBuffer [50] ;
      static HWND  hwndButton [NUM] ;
      static RECT  rect ;
      static int   cxChar, cyChar ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      int          i ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;
                ReleaseDC (hwnd, hdc) ;

                for (i = 0 ; i < NUM ; i++)
                     hwndButton [i] = CreateWindow ("button", button[i].text,
                               WS_CHILD | WS_VISIBLE | button[i].style,
                               cxChar, cyChar * (1 + 2 * i),
                               20 * cxChar, 7 * cyChar / 4,
                               hwnd, i,
                               ((LPCREATESTRUCT) lParam) -> hInstance, NULL) ;
                return 0 ;

           case WM_SIZE:
                rect.left   = 24 * cxChar ;
                rect.top    =  3 * cyChar ;
                rect.right  = LOWORD (lParam) ;
                rect.bottom = HIWORD (lParam) ;
                return 0 ;

           case WM_PAINT:
                InvalidateRect (hwnd, &rect, TRUE) ;

                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                SetBkMode (hdc, TRANSPARENT) ;

                TextOut (hdc, 24 * cxChar, 1 * cyChar, szPrm, sizeof szPrm - 1
                TextOut (hdc, 24 * cxChar, 2 * cyChar, szTop, sizeof szTop - 1
                TextOut (hdc, 24 * cxChar, 2 * cyChar, szUnd, sizeof szUnd - 1

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_COMMAND:
                ScrollWindow (hwnd, 0, -cyChar, &rect, &rect) ;
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                TextOut (hdc, 24 * cxChar, cyChar * (rect.bottom / cyChar - 1)
                         szBuffer, sprintf (szBuffer, szFormat, wParam,
                         LOWORD (lParam), HIWORD (lParam))) ;

                ReleaseDC (hwnd, hdc) ;
                ValidateRect (hwnd, NULL) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CHECKER1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP04\CHECKER1.C

 /*-------------------------------------------------
    CHECKER1.C -- Mouse Hit-Test Demo Program No. 1
                  (c) Charles Petzold, 1990
   -------------------------------------------------*/

 #include <windows.h>
 #define DIVISIONS 5

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR  lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Checker1" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Checker1 Mouse Hit-Test Demo",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL  fState[DIVISIONS][DIVISIONS] ;
      static short cxBlock, cyBlock ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      RECT         rect ;
      short        x, y ;

      switch (message)
           {
           case WM_SIZE:
                cxBlock = LOWORD (lParam) / DIVISIONS ;
                cyBlock = HIWORD (lParam) / DIVISIONS ;
                return 0 ;

           case WM_LBUTTONDOWN:
                x = LOWORD (lParam) / cxBlock ;
                y = HIWORD (lParam) / cyBlock ;

                if (x < DIVISIONS && y < DIVISIONS)
                     {
                     fState [x][y] ^= 1 ;

                     rect.left   = x * cxBlock ;
                     rect.top    = y * cyBlock ;
                     rect.right  = (x + 1) * cxBlock ;
                     rect.bottom = (y + 1) * cyBlock ;

                     InvalidateRect (hwnd, &rect, FALSE) ;
                     }
                else
                     MessageBeep (0) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (x = 0 ; x < DIVISIONS ; x++)
                     for (y = 0 ; y < DIVISIONS ; y++)
                          {
                          Rectangle (hdc, x * cxBlock, y * cyBlock,
                                    (x + 1) * cxBlock, (y + 1) * cyBlock) ;

                          if (fState [x][y])
                               {
                               MoveTo (hdc,  x    * cxBlock,  y    * cyBlock)
                               LineTo (hdc, (x+1) * cxBlock, (y+1) * cyBlock)
                               MoveTo (hdc,  x    * cxBlock, (y+1) * cyBlock)
                               LineTo (hdc, (x+1) * cxBlock,  y    * cyBlock)
                               }
                          }
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CHECKER2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP04\CHECKER2.C

 /*-------------------------------------------------
    CHECKER2.C -- Mouse Hit-Test Demo Program No. 2
                  (c) Charles Petzold, 1990
   -------------------------------------------------*/

 #include <windows.h>
 #define DIVISIONS 5

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Checker2" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Checker2 Mouse Hit-Test Demo",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL  fState[DIVISIONS][DIVISIONS] ;
      static short cxBlock, cyBlock ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      POINT        point ;
      RECT         rect ;
      short        x, y ;

      switch (message)
           {
           case WM_SIZE:
                cxBlock = LOWORD (lParam) / DIVISIONS ;
                cyBlock = HIWORD (lParam) / DIVISIONS ;
                return 0 ;

           case WM_SETFOCUS:
                ShowCursor (TRUE) ;
                return 0 ;

           case WM_KILLFOCUS:
                ShowCursor (FALSE) ;
                return 0 ;

           case WM_KEYDOWN:
                GetCursorPos (&point) ;
                ScreenToClient (hwnd, &point) ;

                x = max (0, min (DIVISIONS - 1, point.x / cxBlock)) ;
                y = max (0, min (DIVISIONS - 1, point.y / cyBlock)) ;

                switch (wParam)
                     {
                     case VK_UP:
                          y -- ;
                          break ;

                     case VK_DOWN:
                          y ++ ;
                          break ;

                     case VK_LEFT:
                          x -- ;
                          break ;

                     case VK_RIGHT:
                          x ++ ;
                          break ;

                     case VK_HOME:
                          x = y = 0 ;
                          break ;

                     case VK_END:
                          x = y = DIVISIONS - 1 ;
                          break ;

                     case VK_RETURN:
                     case VK_SPACE:
                          SendMessage (hwnd, WM_LBUTTONDOWN, MK_LBUTTON,
                                    MAKELONG (x * cxBlock, y * cyBlock)) ;
                          break ;
                     }
                x = (x + DIVISIONS) % DIVISIONS ;
                y = (y + DIVISIONS) % DIVISIONS ;

                point.x = x * cxBlock + cxBlock / 2 ;
                point.y = y * cyBlock + cyBlock / 2 ;

                ClientToScreen (hwnd, &point) ;
                SetCursorPos (point.x, point.y) ;
                return 0 ;

           case WM_LBUTTONDOWN:
                x = LOWORD (lParam) / cxBlock ;
                y = HIWORD (lParam) / cyBlock ;

                if (x < DIVISIONS && y < DIVISIONS)
                     {
                     fState[x][y] ^= 1 ;

                     rect.left   = x * cxBlock ;
                     rect.top    = y * cyBlock ;
                     rect.right  = (x + 1) * cxBlock ;
                     rect.bottom = (y + 1) * cyBlock ;

                     InvalidateRect (hwnd, &rect, FALSE) ;
                     }
                else
                     MessageBeep (0) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (x = 0 ; x < DIVISIONS ; x++)
                     for (y = 0 ; y < DIVISIONS ; y++)
                          {
                          Rectangle (hdc, x * cxBlock, y * cyBlock,
                                    (x + 1) * cxBlock, (y + 1) * cyBlock) ;

                          if (fState [x][y])
                               {
                               MoveTo (hdc,  x    * cxBlock,  y    * cyBlock)
                               LineTo (hdc, (x+1) * cxBlock, (y+1) * cyBlock)
                               MoveTo (hdc,  x    * cxBlock, (y+1) * cyBlock)
                               LineTo (hdc, (x+1) * cxBlock,  y    * cyBlock)
                               }
                          }
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CHECKER3.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP04\CHECKER3.C

 /*-------------------------------------------------
    CHECKER3.C -- Mouse Hit-Test Demo Program No. 3
                  (c) Charles Petzold, 1990
   -------------------------------------------------*/

 #include <windows.h>
 #define DIVISIONS 5

 long FAR PASCAL WndProc      (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL ChildWndProc (HWND, WORD, WORD, LONG) ;

 char szChildClass[] = "Checker3_Child" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Checker3" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;

           wndclass.lpfnWndProc   = ChildWndProc ;
           wndclass.cbWndExtra    = sizeof (WORD) ;
           wndclass.hIcon         = NULL ;
           wndclass.lpszClassName = szChildClass ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Checker3 Mouse Hit-Test Demo",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HWND hwndChild [DIVISIONS] [DIVISIONS] ;
      short       cxBlock, cyBlock, x, y ;

      switch (message)
           {
           case WM_CREATE:
                for (x = 0 ; x < DIVISIONS ; x++)
                     for (y = 0 ; y < DIVISIONS ; y++)
                          {
                          hwndChild [x][y] = CreateWindow (szChildClass, NULL,
                               WS_CHILDWINDOW | WS_VISIBLE,
                               0, 0, 0, 0,
                               hwnd, y << 8 | x,
                               GetWindowWord (hwnd, GWW_HINSTANCE), NULL) ;
                          }
                return 0 ;

           case WM_SIZE:
                cxBlock = LOWORD (lParam) / DIVISIONS ;
                cyBlock = HIWORD (lParam) / DIVISIONS ;

                for (x = 0 ; x < DIVISIONS ; x++)
                     for (y = 0 ; y < DIVISIONS ; y++)
                          MoveWindow (hwndChild [x][y],
                               x * cxBlock, y * cyBlock,
                               cxBlock, cyBlock, TRUE) ;
                return 0 ;

           case WM_LBUTTONDOWN:
                MessageBeep (0) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL ChildWndProc (HWND hwnd, WORD message, WORD wParam, LONG lPar
      {
      HDC         hdc ;
      PAINTSTRUCT ps ;
      RECT        rect ;

      switch (message)
           {
           case WM_CREATE:
                SetWindowWord (hwnd, 0, 0) ;       // on/off flag
                return 0 ;

           case WM_LBUTTONDOWN:
                SetWindowWord (hwnd, 0, 1 ^ GetWindowWord (hwnd, 0)) ;
                InvalidateRect (hwnd, NULL, FALSE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                GetClientRect (hwnd, &rect) ;
                Rectangle (hdc, 0, 0, rect.right, rect.bottom) ;

                if (GetWindowWord (hwnd, 0))
                     {
                     MoveTo (hdc, 0,          0) ;
                     LineTo (hdc, rect.right, rect.bottom) ;
                     MoveTo (hdc, 0,          rect.bottom) ;
                     LineTo (hdc, rect.right, 0) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CLIPVIEW.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP16\CLIPVIEW.C

 /*-----------------------------------------
    CLIPVIEW.C -- Simple Clipboard Viewer
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static    char szAppName [] = "ClipView" ;
      HWND      hwnd ;
      MSG       msg ;
      WNDCLASS  wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Simple Clipboard Viewer (Text Only)",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HWND hwndNextViewer ;
      HANDLE      hGMem ;
      HDC         hdc ;
      LPSTR       lpGMem ;
      PAINTSTRUCT ps ;
      RECT        rect ;

      switch (message)
           {
           case WM_CREATE:
                hwndNextViewer = SetClipboardViewer (hwnd) ;
                return 0 ;

           case WM_CHANGECBCHAIN :
                if (wParam == hwndNextViewer)
                     hwndNextViewer = LOWORD (lParam) ;

                else if (hwndNextViewer)
                     SendMessage (hwndNextViewer, message, wParam, lParam) ;

                return 0 ;

           case WM_DRAWCLIPBOARD :
                if (hwndNextViewer)
                     SendMessage (hwndNextViewer, message, wParam, lParam) ;

                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                GetClientRect (hwnd, &rect) ;
                OpenClipboard (hwnd) ;

                if (hGMem = GetClipboardData (CF_TEXT))
                     {
                     lpGMem = GlobalLock (hGMem) ;
                     DrawText (hdc, lpGMem, -1, &rect, DT_EXPANDTABS) ;
                     GlobalUnlock (hGMem) ;
                     }

                CloseClipboard () ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                ChangeClipboardChain (hwnd, hwndNextViewer) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CLOVER.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP12\CLOVER.C

 /*--------------------------------------------------
    CLOVER.C -- Clover Drawing Program using Regions
                (c) Charles Petzold, 1990
   --------------------------------------------------*/

 #include <windows.h>
 #include <math.h>
 #define TWO_PI (2.0 * 3.14159)

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Clover" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Draw a Clover",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HRGN  hRgnClip ;
      static short cxClient, cyClient ;
      double       fAngle, fRadius ;
      HCURSOR      hCursor ;
      HDC          hdc ;
      HRGN         hRgnTemp [6] ;
      PAINTSTRUCT  ps ;
      short        i ;

      switch (message)
           {
           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;

                hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
                ShowCursor (TRUE) ;

                if (hRgnClip)
                     DeleteObject (hRgnClip) ;

                hRgnTemp [0] = CreateEllipticRgn (0, cyClient / 3,
                                         cxClient / 2, 2 * cyClient / 3) ;
                hRgnTemp [1] = CreateEllipticRgn (cxClient / 2, cyClient / 3,
                                         cxClient, 2 * cyClient / 3) ;
                hRgnTemp [2] = CreateEllipticRgn (cxClient / 3, 0,
                                         2 * cxClient / 3, cyClient / 2) ;
                hRgnTemp [3] = CreateEllipticRgn (cxClient / 3, cyClient / 2,
                                         2 * cxClient / 3, cyClient) ;
                hRgnTemp [4] = CreateRectRgn (0, 0, 1, 1) ;
                hRgnTemp [5] = CreateRectRgn (0, 0, 1, 1) ;
                hRgnClip     = CreateRectRgn (0, 0, 1, 1) ;

                CombineRgn (hRgnTemp [4], hRgnTemp [0], hRgnTemp [1], RGN_OR)
                CombineRgn (hRgnTemp [5], hRgnTemp [2], hRgnTemp [3], RGN_OR)
                CombineRgn (hRgnClip,     hRgnTemp [4], hRgnTemp [5], RGN_XOR)

                for (i = 0 ; i < 6 ; i++)
                     DeleteObject (hRgnTemp [i]) ;

                SetCursor (hCursor) ;
                ShowCursor (FALSE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                SetViewportOrg (hdc, cxClient / 2, cyClient / 2) ;
                SelectClipRgn (hdc, hRgnClip) ;

                fRadius = hypot (cxClient / 2.0, cyClient / 2.0) ;

                for (fAngle = 0.0 ; fAngle < TWO_PI ; fAngle += TWO_PI / 360)
                     {
                     MoveTo (hdc, 0, 0) ;
                     LineTo (hdc, (short) ( fRadius * cos (fAngle) + 0.5),
                                  (short) (-fRadius * sin (fAngle) + 0.5)) ;
                     }
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                DeleteObject (hRgnClip) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 COLORS1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP06\COLORS1.C

 /*----------------------------------------
    COLORS1.C -- Colors Using Scroll Bars
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>

 long FAR PASCAL WndProc    (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL ScrollProc (HWND, WORD, WORD, LONG) ;

 FARPROC lpfnOldScr[3] ;
 HWND    hwndScrol[3], hwndLabel[3], hwndValue[3], hwndRect ;
 short   color[3], nFocus ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Colors1" ;
      static char *szColorLabel[] = { "Red", "Green", "Blue" } ;
      FARPROC     lpfnScrollProc ;
      HWND        hwnd ;
      MSG         msg;
      short       n ;
      WNDCLASS    wndclass ;

      if (hPrevInstance)
           return FALSE ;

      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
      wndclass.lpfnWndProc   = WndProc ;
      wndclass.cbClsExtra    = 0 ;
      wndclass.cbWndExtra    = 0 ;
      wndclass.hInstance     = hInstance ;
      wndclass.hIcon         = NULL ;
      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
      wndclass.hbrBackground = CreateSolidBrush (0L) ;
      wndclass.lpszMenuName  = NULL ;
      wndclass.lpszClassName = szAppName ;

      RegisterClass (&wndclass) ;

      hwnd = CreateWindow (szAppName, "Color Scroll",
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      hwndRect = CreateWindow ("static", NULL,
                               WS_CHILD | WS_VISIBLE | SS_WHITERECT,
                               0, 0, 0, 0,
                               hwnd, 9, hInstance, NULL) ;

      lpfnScrollProc = MakeProcInstance ((FARPROC) ScrollProc, hInstance) ;

      for (n = 0 ; n < 3 ; n++)
           {
           hwndScrol[n] = CreateWindow ("scrollbar", NULL,
                               WS_CHILD | WS_VISIBLE | WS_TABSTOP | SBS_VERT,
                               0, 0, 0, 0,
                               hwnd, n, hInstance, NULL) ;

           hwndLabel[n] = CreateWindow ("static", szColorLabel[n],
                               WS_CHILD | WS_VISIBLE | SS_CENTER,
                               0, 0, 0, 0,
                               hwnd, n + 3, hInstance, NULL) ;

           hwndValue[n] = CreateWindow ("static", "0",
                               WS_CHILD | WS_VISIBLE | SS_CENTER,
                               0, 0, 0, 0,
                               hwnd, n + 6, hInstance, NULL) ;

           lpfnOldScr[n] = (FARPROC) GetWindowLong (hwndScrol[n], GWL_WNDPROC)
           SetWindowLong (hwndScrol[n], GWL_WNDPROC, (LONG) lpfnScrollProc) ;

           SetScrollRange (hwndScrol[n], SB_CTL, 0, 255, FALSE) ;
           SetScrollPos   (hwndScrol[n], SB_CTL, 0, FALSE) ;
           }

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage  (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HBRUSH hBrush[3] ;
      char          szbuffer[10] ;
      HDC           hdc ;
      POINT         point ;
      short         n, cxClient, cyClient, cyChar ;
      TEXTMETRIC    tm ;

      switch (message)
           {
           case WM_CREATE :
                hBrush[0] = CreateSolidBrush (RGB (255, 0, 0)) ;
                hBrush[1] = CreateSolidBrush (RGB (0, 255, 0)) ;
                hBrush[2] = CreateSolidBrush (RGB (0, 0, 255)) ;
                return 0 ;

           case WM_SIZE :
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;

                hdc = GetDC (hwnd) ;
                GetTextMetrics (hdc, &tm) ;
                cyChar = tm.tmHeight ;
                ReleaseDC (hwnd, hdc) ;

                MoveWindow (hwndRect, 0, 0, cxClient / 2, cyClient, TRUE) ;

                for (n = 0 ; n < 3 ; n++)
                     {
                     MoveWindow (hwndScrol[n],
                          (2 * n + 1) * cxClient / 14, 2 * cyChar,
                          cxClient / 14, cyClient - 4 * cyChar, TRUE) ;

                     MoveWindow (hwndLabel[n],
                          (4 * n + 1) * cxClient / 28, cyChar / 2,
                          cxClient / 7, cyChar, TRUE) ;

                     MoveWindow (hwndValue[n],
                          (4 * n + 1) * cxClient / 28, cyClient - 3 * cyChar /
                          cxClient / 7, cyChar, TRUE) ;
                     }
                SetFocus (hwnd) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndScrol[nFocus]) ;
                return 0 ;

           case WM_VSCROLL :
                n = GetWindowWord (HIWORD (lParam), GWW_ID) ;

                switch (wParam)
                     {
                     case SB_PAGEDOWN :
                          color[n] += 15 ;         /* fall through */
                     case SB_LINEDOWN :
                          color[n] = min (255, color[n] + 1) ;
                          break ;
                     case SB_PAGEUP :
                          color[n] -= 15 ;         /* fall through */
                     case SB_LINEUP :
                          color[n] = max (0, color[n] - 1) ;
                          break ;
                     case SB_TOP:
                          color[n] = 0 ;
                          break ;
                     case SB_BOTTOM :
                          color[n] = 255 ;
                          break ;
                     case SB_THUMBPOSITION :
                     case SB_THUMBTRACK :
                          color[n] = LOWORD (lParam) ;
                          break ;
                     default :
                          break ;
                     }
                SetScrollPos  (hwndScrol[n], SB_CTL, color[n], TRUE) ;
                SetWindowText (hwndValue[n], itoa (color[n], szbuffer, 10)) ;

                DeleteObject (GetClassWord (hwnd, GCW_HBRBACKGROUND)) ;
                SetClassWord (hwnd, GCW_HBRBACKGROUND,
                     CreateSolidBrush (RGB (color[0], color[1], color[2]))) ;

                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_CTLCOLOR:
                if (HIWORD (lParam) == CTLCOLOR_SCROLLBAR)
                     {
                     SetBkColor (wParam, GetSysColor (COLOR_CAPTIONTEXT)) ;
                     SetTextColor (wParam, GetSysColor (COLOR_WINDOWFRAME)) ;

                     n = GetWindowWord (LOWORD (lParam), GWW_ID) ;
                     point.x = point.y = 0 ;
                     ClientToScreen (hwnd, &point) ;
                     UnrealizeObject (hBrush[n]) ;
                     SetBrushOrg (wParam, point.x, point.y) ;
                     return ((DWORD) hBrush[n]) ;
                     }
                break ;

           case WM_DESTROY:
                DeleteObject (GetClassWord (hwnd, GCW_HBRBACKGROUND)) ;
                for (n = 0 ; n < 3 ; DeleteObject (hBrush [n++])) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL ScrollProc (HWND hwnd, WORD message, WORD wParam, LONG lParam
      {
      short n = GetWindowWord (hwnd, GWW_ID) ;

      switch (message)
           {
           case WM_KEYDOWN:
                if (wParam == VK_TAB)
                     SetFocus (hwndScrol[(n +
                          (GetKeyState (VK_SHIFT) < 0 ? 2 : 1)) % 3]) ;
                break ;

           case WM_SETFOCUS:
                nFocus = n ;
                break ;
           }
      return CallWindowProc (lpfnOldScr[n], hwnd, message, wParam, lParam) ;
      }


 COLORS2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\COLORS2.C

 /*--------------------------------------------------------
    COLORS2.C -- Version using Modeless Dialog Box Version
                 (c) Charles Petzold, 1990
   --------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc     (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL ColorScrDlg (HWND, WORD, WORD, LONG) ;

 HWND hDlgModeless ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Colors2" ;
      HWND        hwnd ;
      MSG         msg;
      WNDCLASS    wndclass ;

      if (hPrevInstance)
           return FALSE ;

      wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
      wndclass.lpfnWndProc   = WndProc ;
      wndclass.cbClsExtra    = 0 ;
      wndclass.cbWndExtra    = 0 ;
      wndclass.hInstance     = hInstance ;
      wndclass.hIcon         = NULL ;
      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
      wndclass.hbrBackground = CreateSolidBrush (0L) ;
      wndclass.lpszMenuName  = NULL ;
      wndclass.lpszClassName = szAppName ;

      RegisterClass (&wndclass) ;

      hwnd = CreateWindow (szAppName, "Color Scroll",
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      hDlgModeless = CreateDialog (hInstance, "ColorScrDlg", hwnd,
                          MakeProcInstance (ColorScrDlg, hInstance)) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (hDlgModeless == 0 || !IsDialogMessage (hDlgModeless, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage  (&msg) ;
                }
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL ColorScrDlg (HWND hDlg, WORD message, WORD wParam, LONG lPara
      {
      static short color [3] ;
      HWND         hwndParent, hCtrl ;
      short        nCtrlID, nIndex ;

      switch (message)
           {
           case WM_INITDIALOG:
                for (nCtrlID = 10 ; nCtrlID < 13 ; nCtrlID++)
                     {
                     hCtrl = GetDlgItem (hDlg, nCtrlID) ;
                     SetScrollRange (hCtrl, SB_CTL, 0, 255, FALSE) ;
                     SetScrollPos   (hCtrl, SB_CTL, 0, FALSE) ;
                     }
                return TRUE ;

           case WM_VSCROLL :
                hCtrl   = HIWORD (lParam) ;
                nCtrlID = GetWindowWord (hCtrl, GWW_ID) ;
                nIndex  = nCtrlID - 10 ;
                hwndParent = GetParent (hDlg) ;

                switch (wParam)
                     {
                     case SB_PAGEDOWN :
                          color [nIndex] += 15 ;        // fall through
                     case SB_LINEDOWN :
                          color [nIndex] = min (255, color [nIndex] + 1) ;
                          break ;
                     case SB_PAGEUP :
                          color [nIndex] -= 15 ;        // fall through
                     case SB_LINEUP :
                          color [nIndex] = max (0, color [nIndex] - 1) ;
                          break ;
                     case SB_TOP:
                          color [nIndex] = 0 ;
                          break ;
                     case SB_BOTTOM :
                          color [nIndex] = 255 ;
                          break ;
                     case SB_THUMBPOSITION :
                     case SB_THUMBTRACK :
                          color [nIndex] = LOWORD (lParam) ;
                          break ;
                     default :
                          return FALSE ;
                     }
                SetScrollPos  (hCtrl, SB_CTL,      color [nIndex], TRUE) ;
                SetDlgItemInt (hDlg,  nCtrlID + 3, color [nIndex], FALSE) ;

                DeleteObject (GetClassWord (hwndParent, GCW_HBRBACKGROUND)) ;
                SetClassWord (hwndParent, GCW_HBRBACKGROUND,
                     CreateSolidBrush (RGB (color [0], color [1], color [2])))

                InvalidateRect (hwndParent, NULL, TRUE) ;
                return TRUE ;
           }
      return FALSE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_DESTROY:
                DeleteObject (GetClassWord (hwnd, GCW_HBRBACKGROUND)) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 CONNECT.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP04\CONNECT.C

 /*--------------------------------------------------
    CONNECT.C -- Connect-the-Dots Mouse Demo Program
                 (c) Charles Petzold, 1990
   --------------------------------------------------*/

 #include <windows.h>
 #define MAXPOINTS 1000

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Connect" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Connect-the-Points Mouse Demo",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static POINT points[MAXPOINTS] ;
      static short nCount ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      short        i, j ;

      switch (message)
           {
           case WM_LBUTTONDOWN:
                nCount = 0 ;
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_MOUSEMOVE:
                if (wParam & MK_LBUTTON && nCount < 1000)
                     {
                     points [nCount++] = MAKEPOINT (lParam) ;
                     hdc = GetDC (hwnd) ;
                     SetPixel (hdc, LOWORD (lParam), HIWORD (lParam), 0L) ;
                     ReleaseDC (hwnd, hdc) ;
                     }
                return 0 ;

           case WM_LBUTTONUP:
                InvalidateRect (hwnd, NULL, FALSE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (i = 0 ; i < nCount - 1 ; i++)
                     for (j = i ; j < nCount ; j++)
                          {
                          MoveTo (hdc, points[i].x, points[i].y) ;
                          LineTo (hdc, points[j].x, points[j].y) ;
                          }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 DDEPOP.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP17\DDEPOP.C

 /*--------------------------------------------
    DDEPOP.C -- DDE Server for Population Data
                (c) Charles Petzold, 1990
   --------------------------------------------*/

 #include <windows.h>
 #include <dde.h>
 #include <string.h>
 #include <time.h>

 struct
      {
      char *szState ;
      long lPop70 ;
      long lPop80 ;
      long lPop ;
      }
      pop [] = {
               "AL",   3444354,   3894025, 0, "AK",    302583,    401851, 0,
               "AZ",   1775399,   2716598, 0, "AR",   1923322,   2286357, 0,
               "CA",  19971069,  23667764, 0, "CO",   2209596,   2889735, 0,
               "CT",   3032217,   3107564, 0, "DE",    548104,    594338, 0,
               "DC",    756668,    638432, 0, "FL",   6791418,   9746961, 0,
               "GA",   4587930,   5462982, 0, "HI",    769913,    964691, 0,
               "ID",    713015,    944127, 0, "IL",  11110285,  11427409, 0,
               "IN",   5195392,   5490212, 0, "IA",   2825368,   2913808, 0,
               "KS",   2249071,   2364236, 0, "KY",   3220711,   3660324, 0,
               "LA",   3644637,   4206116, 0, "ME",    993722,   1125043, 0,
               "MD",   3923897,   4216933, 0, "MA",   5689170,   5737093, 0,
               "MI",   8881826,   9262044, 0, "MN",   3806103,   4075970, 0,
               "MS",   2216994,   2520770, 0, "MO",   4677623,   4916762, 0,
               "MT",    694409,    786690, 0, "NE",   1485333,   1569825, 0,
               "NV",    488738,    800508, 0, "NH",    737681,    920610, 0,
               "NJ",   7171112,   7365011, 0, "NM",   1017055,   1303302, 0,
               "NY",  18241391,  17558165, 0, "NC",   5084411,   5880415, 0,
               "ND",    617792,    652717, 0, "OH",  10657423,  10797603, 0,
               "OK",   2559463,   3025487, 0, "OR",   2091533,   2633156, 0,
               "PA",  11800766,  11864720, 0, "RI",    949723,    947154, 0,
               "SC",   2590713,   3120730, 0, "SD",    666257,    690768, 0,
               "TN",   3926018,   4591023, 0, "TX",  11198655,  14225513, 0,
               "UT",   1059273,   1461037, 0, "VT",    444732,    511456, 0,
               "VA",   4651448,   5346797, 0, "WA",   3413244,   4132353, 0,
               "WV",   1744237,   1950186, 0, "WI",   4417821,   4705642, 0,
               "WY",    332416,    469557, 0, "US", 203302031, 226542580, 0
               } ;

 #define NUM_STATES (sizeof (pop) / sizeof (pop [0]))

 typedef struct
      {
      unsigned int fAdvise:1 ;
      unsigned int fDeferUpd:1 ;
      unsigned int fAckReq:1 ;
      unsigned int dummy:13 ;
      long         lPopPrev ;
      }
      POPADVISE ;

 #define ID_TIMER    1
 #define DDE_TIMEOUT 3000

 long FAR PASCAL WndProc         (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL ServerProc      (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL TimerEnumProc   (HWND, LONG) ;
 BOOL FAR PASCAL CloseEnumProc   (HWND, LONG) ;
 BOOL            PostDataMessage (HWND, HWND, int, BOOL, BOOL, BOOL) ;

 char   szAppName []     = "DdePop" ;
 char   szServerClass [] = "DdePop.Server" ;
 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (hPrevInstance)
           return FALSE ;

      hInst = hInstance ;

                // Register window class

      wndclass.style         = 0 ;
      wndclass.lpfnWndProc   = WndProc ;
      wndclass.cbClsExtra    = 0 ;
      wndclass.cbWndExtra    = 0 ;
      wndclass.hInstance     = hInstance ;
      wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
      wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
      wndclass.lpszMenuName  = NULL ;
      wndclass.lpszClassName = szAppName ;

      RegisterClass (&wndclass) ;

                // Register window class for DDE Server

      wndclass.style         = 0 ;
      wndclass.lpfnWndProc   = ServerProc ;
      wndclass.cbClsExtra    = 0 ;
      wndclass.cbWndExtra    = 2 * sizeof (WORD) ;
      wndclass.hInstance     = hInstance ;
      wndclass.hIcon         = NULL ;
      wndclass.hCursor       = NULL ;
      wndclass.hbrBackground = NULL ;
      wndclass.lpszMenuName  = NULL ;
      wndclass.lpszClassName = szServerClass ;

      RegisterClass (&wndclass) ;

      hwnd = CreateWindow (szAppName, "DDE Population Server",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      SendMessage (hwnd, WM_TIMER, 0, 0L) ;   // initialize 'pop' structure

      if (!SetTimer (hwnd, ID_TIMER, 5000, NULL))
           {
           MessageBox (hwnd, "Too many clocks or timers!", szAppName,
                       MB_ICONEXCLAMATION | MB_OK) ;

           return FALSE ;
           }

      ShowWindow (hwnd, SW_SHOWMINNOACTIVE) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }

      KillTimer (hwnd, ID_TIMER) ;

      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpTimerEnumProc, lpCloseEnumProc ;
      static char    szTopic [] = "US_Population" ;
      ATOM           aApp, aTop ;
      HWND           hwndClient, hwndServer ;
      int            i ;
      long double    ldSecsInDecade, ldSecSince1970 ;
      time_t         lSecSince1970 ;

      switch (message)
           {
           case WM_CREATE:
                lpTimerEnumProc = MakeProcInstance (TimerEnumProc, hInst) ;
                lpCloseEnumProc = MakeProcInstance (CloseEnumProc, hInst) ;
                return 0 ;

           case WM_DDE_INITIATE:

                     // wParam          -- sending window handle
                     // LOWORD (lParam) -- application atom
                     // HIWORD (lParam) -- topic atom

                hwndClient = wParam ;

                aApp = GlobalAddAtom (szAppName) ;
                aTop = GlobalAddAtom (szTopic) ;

                     // Check for matching atoms, create window, and acknowled

                if ((LOWORD (lParam) == NULL || LOWORD (lParam) == aApp) &&
                    (HIWORD (lParam) == NULL || HIWORD (lParam) == aTop))
                     {
                     hwndServer = CreateWindow (szServerClass, NULL,
                                                WS_CHILD, 0, 0, 0, 0,
                                                hwnd, NULL, hInst, NULL) ;

                     SetWindowWord (hwndServer, 0, hwndClient) ;
                     SendMessage (wParam, WM_DDE_ACK, hwndServer,
                                  MAKELONG (aApp, aTop)) ;
                     }

                     // Otherwise, delete the atoms just created

                else
                     {
                     GlobalDeleteAtom (aApp) ;
                     GlobalDeleteAtom (aTop) ;
                     }

                return 0 ;

           case WM_TIMER:
           case WM_TIMECHANGE:
                time (&lSecSince1970) ;

                     // Calculate new current populations

                ldSecSince1970 = (long double) lSecSince1970 ;
                ldSecsInDecade = (long double) 3652 * 24 * 60 * 60 ;

                for (i = 0 ; i < NUM_STATES ; i++)
                     {
                     pop[i].lPop = (long)
                          (((ldSecsInDecade - ldSecSince1970) * pop[i].lPop70
                             ldSecSince1970 * pop[i].lPop80) / ldSecsInDecade
                                    + .5) ;
                     }

                     // Notify all child windows

                EnumChildWindows (hwnd, lpTimerEnumProc, 0L) ;
                return 0 ;

           case WM_QUERYOPEN:
                return 0 ;

           case WM_CLOSE:

                     // Notify all child windows

                EnumChildWindows (hwnd, lpCloseEnumProc, 0L) ;

                break ;                  // for default processing

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL ServerProc (HWND hwnd, WORD message, WORD wParam, LONG lParam
      {
      ATOM          aItem ;
      char          szItem [10], szPopulation [10] ;
      DDEACK        DdeAck ;
      DDEADVISE     Advise ;
      DDEADVISE FAR *lpDdeAdvise ;
      DDEDATA FAR   *lpDdeData ;
      DWORD         dwTime ;
      GLOBALHANDLE  hPopAdvise, hDdeData, hDdeAdvise, hCommands, hDdePoke ;
      int           i ;
      HWND          hwndClient ;
      MSG           msg ;
      POPADVISE FAR *lpPopAdvise ;
      WORD          cfFormat, wStatus ;

      switch (message)
           {
           case WM_CREATE:

                     // Allocate memory for POPADVISE structures

                hPopAdvise = GlobalAlloc (GHND, NUM_STATES * sizeof (POPADVISE

                if (hPopAdvise == NULL)
                     DestroyWindow (hwnd) ;
                else
                     SetWindowWord (hwnd, 2, hPopAdvise) ;

                return 0 ;

           case WM_DDE_REQUEST:

                     // wParam          -- sending window handle
                     // LOWORD (lParam) -- data format
                     // HIWORD (lParam) -- item atom

                hwndClient = wParam ;
                cfFormat   = LOWORD (lParam) ;
                aItem      = HIWORD (lParam) ;

                     // Check for matching format and data item

                if (cfFormat == CF_TEXT)
                     {
                     GlobalGetAtomName (aItem, szItem, sizeof (szItem)) ;

                     for (i = 0 ; i < NUM_STATES ; i++)
                          if (strcmp (szItem, pop[i].szState) == 0)
                               break ;

                     if (i < NUM_STATES)
                          {
                          GlobalDeleteAtom (aItem) ;
                          PostDataMessage (hwnd, hwndClient, i,
                                           FALSE, FALSE, TRUE) ;
                          return 0 ;
                          }
                     }

                     // Negative acknowledge if no match

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = FALSE ;

                wStatus = * (WORD *) & DdeAck ;

                if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                  MAKELONG (wStatus, aItem)))
                     {
                     GlobalDeleteAtom (aItem) ;
                     }

                return 0 ;

           case WM_DDE_ADVISE:

                     // wParam          -- sending window handle
                     // LOWORD (lParam) -- DDEADVISE memory handle
                     // HIWORD (lParam) -- item atom

                hwndClient = wParam ;
                hDdeAdvise = LOWORD (lParam) ;
                aItem      = HIWORD (lParam) ;

                lpDdeAdvise = (DDEADVISE FAR *) GlobalLock (hDdeAdvise) ;

                     // Check for matching format and data item

                if (lpDdeAdvise->cfFormat == CF_TEXT)
                     {
                     GlobalGetAtomName (aItem, szItem, sizeof (szItem)) ;

                     for (i = 0 ; i < NUM_STATES ; i++)
                          if (strcmp (szItem, pop[i].szState) == 0)
                               break ;

                          // Fill in the POPADVISE structure and acknowledge

                     if (i < NUM_STATES)
                          {
                          hPopAdvise = GetWindowWord (hwnd, 2) ;
                          lpPopAdvise = (POPADVISE FAR *)
                                               GlobalLock (hPopAdvise) ;

                          lpPopAdvise[i].fAdvise   = TRUE ;
                          lpPopAdvise[i].fDeferUpd = lpDdeAdvise->fDeferUpd ;
                          lpPopAdvise[i].fAckReq   = lpDdeAdvise->fAckReq ;
                          lpPopAdvise[i].lPopPrev  = pop[i].lPop ;

                          GlobalUnlock (hDdeAdvise) ;
                          GlobalFree (hDdeAdvise) ;

                          DdeAck.bAppReturnCode = 0 ;
                          DdeAck.reserved       = 0 ;
                          DdeAck.fBusy          = FALSE ;
                          DdeAck.fAck           = TRUE ;

                          wStatus = * (WORD *) & DdeAck ;

                          if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                            MAKELONG (wStatus, aItem)))
                               {
                               GlobalDeleteAtom (aItem) ;
                               }
                          else
                               {
                               PostDataMessage (hwnd, hwndClient, i,
                                                lpPopAdvise[i].fDeferUpd,
                                                lpPopAdvise[i].fAckReq,
                                                FALSE) ;
                               }

                          GlobalUnlock (hPopAdvise) ;
                          return 0 ;
                          }
                     }

                          // Otherwise post a negative WM_DDE_ACK

                GlobalUnlock (hDdeAdvise) ;

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = FALSE ;

                wStatus = * (WORD *) & DdeAck ;

                if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                  MAKELONG (wStatus, aItem)))
                     {
                     GlobalFree (hDdeAdvise) ;
                     GlobalDeleteAtom (aItem) ;
                     }

                return 0 ;

           case WM_DDE_UNADVISE:

                     // wParam          -- sending window handle
                     // LOWORD (lParam) -- data format
                     // HIWORD (lParam) -- item atom

                hwndClient = wParam ;
                cfFormat   = LOWORD (lParam) ;
                aItem      = HIWORD (lParam) ;

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = TRUE ;

                hPopAdvise  = GetWindowWord (hwnd, 2) ;
                lpPopAdvise = (POPADVISE FAR *) GlobalLock (hPopAdvise) ;

                     // Check for matching format and data item

                if (cfFormat == CF_TEXT || cfFormat == 0)
                     {
                     if (aItem == NULL)
                          for (i = 0 ; i < NUM_STATES ; i++)
                               lpPopAdvise[i].fAdvise = FALSE ;
                     else
                          {
                          GlobalGetAtomName (aItem, szItem, sizeof (szItem)) ;

                          for (i = 0 ; i < NUM_STATES ; i++)
                               if (strcmp (szItem, pop[i].szState) == 0)
                                    break ;

                          if (i < NUM_STATES)
                               lpPopAdvise[i].fAdvise = FALSE ;
                          else
                               DdeAck.fAck = FALSE ;
                          }
                     }
                else
                     DdeAck.fAck = FALSE ;

                     // Acknowledge either positively or negatively

                wStatus = * (WORD *) & DdeAck ;

                if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                  MAKELONG (wStatus, aItem)))
                     {
                     if (aItem != NULL)
                          GlobalDeleteAtom (aItem) ;
                     }

                GlobalUnlock (hPopAdvise) ;
                return 0 ;

           case WM_DDE_EXECUTE:

                     // Post negative acknowledge

                hwndClient = wParam ;
                hCommands  = HIWORD (lParam) ;

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = FALSE ;

                wStatus = * (WORD *) & DdeAck ;

                if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                  MAKELONG (wStatus, hCommands)))
                     {
                     GlobalFree (hCommands) ;
                     }
                return 0 ;

           case WM_DDE_POKE:

                     // Post negative acknowledge

                hwndClient = wParam ;
                hDdePoke   = LOWORD (lParam) ;
                aItem      = HIWORD (lParam) ;

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = FALSE ;

                wStatus = * (WORD *) & DdeAck ;

                if (!PostMessage (hwndClient, WM_DDE_ACK, hwnd,
                                  MAKELONG (wStatus, aItem)))
                     {
                     GlobalFree (hDdePoke) ;
                     GlobalDeleteAtom (aItem) ;
                     }

                return 0 ;

           case WM_DDE_TERMINATE:

                     // Respond with another WM_DDE_TERMINATE message

                hwndClient = wParam ;
                PostMessage (hwndClient, WM_DDE_TERMINATE, hwnd, 0L) ;
                DestroyWindow (hwnd) ;
                return 0 ;

           case WM_TIMER:

                     // Post WM_DDE_DATA messages for changed populations

                hwndClient  = GetWindowWord (hwnd, 0) ;
                hPopAdvise  = GetWindowWord (hwnd, 2) ;
                lpPopAdvise = (POPADVISE FAR *) GlobalLock (hPopAdvise) ;

                for (i = 0 ; i < NUM_STATES ; i++)
                     if (lpPopAdvise[i].fAdvise)
                          if (lpPopAdvise[i].lPopPrev != pop[i].lPop)
                               {
                               if (!PostDataMessage (hwnd, hwndClient, i,
                                                     lpPopAdvise[i].fDeferUpd,
                                                     lpPopAdvise[i].fAckReq,
                                                     FALSE))
                                    break ;

                               lpPopAdvise[i].lPopPrev = pop[i].lPop ;
                               }

                GlobalUnlock (hPopAdvise) ;
                return 0 ;

           case WM_CLOSE:

                     // Post a WM_DDE_TERMINATE message to the client

                hwndClient = GetWindowWord (hwnd, 0) ;
                PostMessage (hwndClient, WM_DDE_TERMINATE, hwnd, 0L) ;

                dwTime = GetCurrentTime () ;

                while (GetCurrentTime () - dwTime < DDE_TIMEOUT)
                     if (PeekMessage (&msg, hwnd, WM_DDE_TERMINATE,
                                      WM_DDE_TERMINATE, PM_REMOVE))
                          break ;

                DestroyWindow (hwnd) ;
                return 0 ;

           case WM_DESTROY:
                hPopAdvise = GetWindowWord (hwnd, 2) ;
                GlobalFree (hPopAdvise) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 BOOL FAR PASCAL TimerEnumProc (HWND hwnd, LONG lParam)
      {
      SendMessage (hwnd, WM_TIMER, 0, 0L) ;

      return TRUE ;
      }

 BOOL FAR PASCAL CloseEnumProc (HWND hwnd, LONG lParam)
      {
      SendMessage (hwnd, WM_CLOSE, 0, 0L) ;

      return TRUE ;
      }

 BOOL PostDataMessage (HWND hwndServer, HWND hwndClient, int iState,
                       BOOL fDeferUpd, BOOL fAckReq, BOOL fResponse)
      {
      ATOM         aItem ;
      char         szPopulation [10] ;
      DDEACK       DdeAck ;
      DDEDATA FAR  *lpDdeData ;
      DWORD        dwTime ;
      GLOBALHANDLE hDdeData ;
      MSG          msg ;

      aItem = GlobalAddAtom (pop[iState].szState) ;

           // Allocate a DDEDATA structure if not defered update

      if (fDeferUpd)
           {
           hDdeData = NULL ;
           }
      else
           {
           wsprintf (szPopulation, "%ld\r\n", pop[iState].lPop) ;

           hDdeData = GlobalAlloc (GHND | GMEM_DDESHARE,
                                   sizeof (DDEDATA) + strlen (szPopulation)) ;

           lpDdeData = (DDEDATA FAR *) GlobalLock (hDdeData) ;

           lpDdeData->fResponse = fResponse ;
           lpDdeData->fRelease  = TRUE ;
           lpDdeData->fAckReq   = fAckReq ;
           lpDdeData->cfFormat  = CF_TEXT ;

           lstrcpy ((LPSTR) lpDdeData->Value, szPopulation) ;

           GlobalUnlock (hDdeData) ;
           }

           // Post the WM_DDE_DATA message

      if (!PostMessage (hwndClient, WM_DDE_DATA, hwndServer,
                        MAKELONG (hDdeData, aItem)))
           {
           if (hDdeData != NULL)
                GlobalFree (hDdeData) ;

           GlobalDeleteAtom (aItem) ;
           return FALSE ;
           }

           // Wait for the acknowledge message if it's requested

      if (fAckReq)
           {
           DdeAck.fAck = FALSE ;

           dwTime = GetCurrentTime () ;

           while (GetCurrentTime () - dwTime < DDE_TIMEOUT)
                {
                if (PeekMessage (&msg, hwndServer, WM_DDE_ACK, WM_DDE_ACK,
                                 PM_REMOVE))
                     {
                     DdeAck = * (DDEACK *) & LOWORD (msg.lParam) ;
                     aItem  = HIWORD (msg.lParam) ;
                     GlobalDeleteAtom (aItem) ;
                     break ;
                     }
                }

           if (DdeAck.fAck == FALSE)
                {
                if (hDdeData != NULL)
                     GlobalFree (hDdeData) ;

                return FALSE ;
                }
           }

      return TRUE ;
      }


 DEVCAPS.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\DEVCAPS.C

 /*---------------------------------------------------------
    DEVCAPS.C -- Display routines for DEVCAPS1 and DEVCAPS2
                 (c) Charles Petzold, 1990
   ---------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include <stdio.h>

 typedef struct
      {
      short nMask ;
      char  *szMask ;
      char  *szDesc ;
      }
      BITS ;

 void DoBasicInfo (HDC hdc, HDC hdcInfo, short cxChar, short cyChar)
      {
      static struct
           {
           short nIndex ;
           char  *szDesc ;
           }
           info [] =
           {
           HORZSIZE,      "HORZSIZE     Width in millimeters:",
           VERTSIZE,      "VERTSIZE     Height in millimeters:",
           HORZRES,       "HORZRES      Width in pixels:",
           VERTRES,       "VERTRES      Height in raster lines:",
           BITSPIXEL,     "BITSPIXEL    Color bits per pixel:",
           PLANES,        "PLANES       Number of color planes:",
           NUMBRUSHES,    "NUMBRUSHES   Number of device brushes:",
           NUMPENS,       "NUMPENS      Number of device pens:",
           NUMMARKERS,    "NUMMARKERS   Number of device markers:",
           NUMFONTS,      "NUMFONTS     Number of device fonts:",
           NUMCOLORS,     "NUMCOLORS    Number of device colors:",
           PDEVICESIZE,   "PDEVICESIZE  Size of device structure:",
           ASPECTX,       "ASPECTX      Relative width of pixel:",
           ASPECTY,       "ASPECTY      Relative height of pixel:",
           ASPECTXY,      "ASPECTXY     Relative diagonal of pixel:",
           LOGPIXELSX,    "LOGPIXELSX   Horizontal dots per inch:",
           LOGPIXELSY,    "LOGPIXELSY   Vertical dots per inch:",
           SIZEPALETTE,   "SIZEPALETTE  Number of palette entries:",
           NUMRESERVED,   "NUMRESERVED  Reserved palette entries:",
           COLORRES,      "COLORRES     Actual color resolution:"
           } ;
      char   szBuffer [80] ;
      short  i, nLine ;

      for (i = 0 ; i < sizeof info / sizeof info [0] ; i++)
           TextOut (hdc, cxChar, (i + 1) * cyChar, szBuffer,
                sprintf (szBuffer, "%-40s%8d", info[i].szDesc,
                     GetDeviceCaps (hdcInfo, info[i].nIndex))) ;
      }

 void DoOtherInfo (HDC hdc, HDC hdcInfo, short cxChar, short cyChar)
      {
      static BITS clip [] =
           {
           CP_RECTANGLE,  "CP_RECTANGLE",     "Can Clip To Rectangle:"
           } ;

      static BITS raster [] =
           {
           RC_BITBLT,       "RC_BITBLT",       "Capable of simple BitBlt:",
           RC_BANDING,      "RC_BANDING",      "Requires banding support:",
           RC_SCALING,      "RC_SCALING",      "Requires scaling support:",
           RC_BITMAP64,     "RC_BITMAP64",     "Supports bitmaps >64K:",
           RC_GDI20_OUTPUT, "RC_GDI20_OUTPUT", "Has 2.0 output calls:",
           RC_DI_BITMAP,    "RC_DI_BITMAP",    "Supports DIB to memory:",
           RC_PALETTE,      "RC_PALETTE",      "Supports a palette:",
           RC_DIBTODEV,     "RC_DIBTODEV",     "Supports bitmap conversion:",
           RC_BIGFONT,      "RC_BIGFONT",      "Supports fonts >64K:",
           RC_STRETCHBLT,   "RC_STRETCHBLT",   "Supports StretchBlt:",
           RC_FLOODFILL,    "RC_FLOODFILL",    "Supports FloodFill:"
           } ;

      static char *szTech [] = { "DT_PLOTTER (Vector plotter)",
                                 "DT_RASDISPLAY (Raster display)",
                                 "DT_RASPRINTER (Raster printer)",
                                 "DT_RASCAMERA (Raster camera)",
                                 "DT_CHARSTREAM (Character-stream, PLP)",
                                 "DT_METAFILE (Metafile, VDM)",
                                 "DT_DISPFILE (Display-file)" } ;
      char        szBuffer [80] ;
      short       i ;

      TextOut (hdc, cxChar, cyChar, szBuffer,
           sprintf (szBuffer, "%-24s%04XH",
                "DRIVERVERSION:", GetDeviceCaps (hdcInfo, DRIVERVERSION))) ;

      TextOut (hdc, cxChar, 2 * cyChar, szBuffer,
           sprintf (szBuffer, "%-24s%-40s",
                "TECHNOLOGY:", szTech [GetDeviceCaps (hdcInfo, TECHNOLOGY)]))

      TextOut (hdc, cxChar, 4 * cyChar, szBuffer,
           sprintf (szBuffer, "CLIPCAPS (Clipping capabilities)")) ;

      for (i = 0 ; i < sizeof clip / sizeof clip [0] ; i++)
           TextOut (hdc, 9 * cxChar, (i + 6) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s%-28s %3s",
                     clip[i].szMask, clip[i].szDesc,
                     GetDeviceCaps (hdcInfo, CLIPCAPS) & clip[i].nMask ?
                          "Yes" : "No")) ;

      TextOut (hdc, cxChar, 8 * cyChar, szBuffer,
           sprintf (szBuffer, "RASTERCAPS (Raster capabilities)")) ;

      for (i = 0 ; i < sizeof raster / sizeof raster [0] ; i++)
           TextOut (hdc, 9 * cxChar, (i + 10) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s%-28s %3s",
                     raster[i].szMask, raster[i].szDesc,
                     GetDeviceCaps (hdcInfo, RASTERCAPS) & raster[i].nMask ?
                          "Yes" : "No")) ;
      }

 void DoBitCodedCaps (HDC hdc, HDC hdcInfo, short cxChar, short cyChar,
                      short nType)
      {
      static BITS curves [] =
           {
           CC_CIRCLES,    "CC_CIRCLES",    "circles:",
           CC_PIE,        "CC_PIE",        "pie wedges:",
           CC_CHORD,      "CC_CHORD",      "chord arcs:",
           CC_ELLIPSES,   "CC_ELLIPSES",   "ellipses:",
           CC_WIDE,       "CC_WIDE",       "wide borders:",
           CC_STYLED,     "CC_STYLED",     "styled borders:",
           CC_WIDESTYLED, "CC_WIDESTYLED", "wide and styled borders:",
           CC_INTERIORS,  "CC_INTERIORS",  "interiors:"
           } ;

      static BITS lines [] =
           {
           LC_POLYLINE,   "LC_POLYLINE",   "polyline:",
           LC_MARKER,     "LC_MARKER",     "markers:",
           LC_POLYMARKER, "LC_POLYMARKER", "polymarkers",
           LC_WIDE,       "LC_WIDE",       "wide lines:",
           LC_STYLED,     "LC_STYLED",     "styled lines:",
           LC_WIDESTYLED, "LC_WIDESTYLED", "wide and styled lines:",
           LC_INTERIORS,  "LC_INTERIORS",  "interiors:"
           } ;

      static BITS poly [] =
           {
           PC_POLYGON,    "PC_POLYGON",    "alternate fill polygon:",
           PC_RECTANGLE,  "PC_RECTANGLE",  "rectangle:",
           PC_TRAPEZOID,  "PC_TRAPEZOID",  "winding number fill polygon:",
           PC_SCANLINE,   "PC_SCANLINE",   "scanlines:",
           PC_WIDE,       "PC_WIDE",       "wide borders:",
           PC_STYLED,     "PC_STYLED",     "styled borders:",
           PC_WIDESTYLED, "PC_WIDESTYLED", "wide and styled borders:",
           PC_INTERIORS,  "PC_INTERIORS",  "interiors:"
           } ;

      static BITS text [] =
           {
           TC_OP_CHARACTER, "TC_OP_CHARACTER", "character output precision:",
           TC_OP_STROKE,    "TC_OP_STROKE",    "stroke output precision:",
           TC_CP_STROKE,    "TC_CP_STROKE",    "stroke clip precision:",
           TC_CR_90,        "TC_CP_90",        "90 degree character rotation:"
           TC_CR_ANY,       "TC_CR_ANY",       "any character rotation:",
           TC_SF_X_YINDEP,  "TC_SF_X_YINDEP", "scaling independent of X and Y:
           TC_SA_DOUBLE,    "TC_SA_DOUBLE",   "doubled character for scaling:"
           TC_SA_INTEGER,   "TC_SA_INTEGER",  "integer multiples for scaling:"
           TC_SA_CONTIN,    "TC_SA_CONTIN",  "any multiples for exact scaling:
           TC_EA_DOUBLE,    "TC_EA_DOUBLE",  "double weight characters:",
           TC_IA_ABLE,      "TC_IA_ABLE",    "italicizing:",
           TC_UA_ABLE,      "TC_UA_ABLE",    "underlining:",
           TC_SO_ABLE,      "TC_SO_ABLE",    "strikeouts:",
           TC_RA_ABLE,      "TC_RA_ABLE",    "raster fonts:",
           TC_VA_ABLE,      "TC_VA_ABLE",    "vector fonts:"
           } ;

      static struct
           {
           short nIndex ;
           char  *szTitle ;
           BITS  (*pbits) [] ;
           short nSize ;
           }
           bitinfo [] =
           {
           CURVECAPS,  "CURVCAPS (Curve Capabilities)",
                       (BITS (*)[]) curves, sizeof curves / sizeof curves [0],
           LINECAPS,   "LINECAPS (Line Capabilities)",
                       (BITS (*)[]) lines, sizeof lines / sizeof lines [0],
           POLYGONALCAPS, "POLYGONALCAPS (Polygonal Capabilities)",
                       (BITS (*)[]) poly, sizeof poly / sizeof poly [0],
           TEXTCAPS,   "TEXTCAPS (Text Capabilities)",
                       (BITS (*)[]) text, sizeof text / sizeof text [0]
           } ;

      static char szBuffer [80] ;
      BITS        (*pbits) [] = bitinfo [nType].pbits ;
      short       nDevCaps = GetDeviceCaps (hdcInfo, bitinfo [nType].nIndex) ;
      short       i ;

      TextOut (hdc, cxChar, cyChar, bitinfo [nType].szTitle,
                     strlen (bitinfo [nType].szTitle)) ;

      for (i = 0 ; i < bitinfo [nType].nSize ; i++)
           TextOut (hdc, cxChar, (i + 3) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s %s %-32s %3s",
                     (*pbits)[i].szMask, "Can do", (*pbits)[i].szDesc,
                     nDevCaps & (*pbits)[i].nMask ? "Yes" : "No")) ;
      }


 DEVCAPS.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP11\DEVCAPS.C

 /*---------------------------------------------------------
    DEVCAPS.C -- Display routines for DEVCAPS1 and DEVCAPS2
                 (c) Charles Petzold, 1990
   ---------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include <stdio.h>

 typedef struct
      {
      short nMask ;
      char  *szMask ;
      char  *szDesc ;
      }
      BITS ;

 void DoBasicInfo (HDC hdc, HDC hdcInfo, short cxChar, short cyChar)
      {
      static struct
           {
           short nIndex ;
           char  *szDesc ;
           }
           info [] =
           {
           HORZSIZE,      "HORZSIZE     Width in millimeters:",
           VERTSIZE,      "VERTSIZE     Height in millimeters:",
           HORZRES,       "HORZRES      Width in pixels:",
           VERTRES,       "VERTRES      Height in raster lines:",
           BITSPIXEL,     "BITSPIXEL    Color bits per pixel:",
           PLANES,        "PLANES       Number of color planes:",
           NUMBRUSHES,    "NUMBRUSHES   Number of device brushes:",
           NUMPENS,       "NUMPENS      Number of device pens:",
           NUMMARKERS,    "NUMMARKERS   Number of device markers:",
           NUMFONTS,      "NUMFONTS     Number of device fonts:",
           NUMCOLORS,     "NUMCOLORS    Number of device colors:",
           PDEVICESIZE,   "PDEVICESIZE  Size of device structure:",
           ASPECTX,       "ASPECTX      Relative width of pixel:",
           ASPECTY,       "ASPECTY      Relative height of pixel:",
           ASPECTXY,      "ASPECTXY     Relative diagonal of pixel:",
           LOGPIXELSX,    "LOGPIXELSX   Horizontal dots per inch:",
           LOGPIXELSY,    "LOGPIXELSY   Vertical dots per inch:",
           SIZEPALETTE,   "SIZEPALETTE  Number of palette entries:",
           NUMRESERVED,   "NUMRESERVED  Reserved palette entries:",
           COLORRES,      "COLORRES     Actual color resolution:"
           } ;
      char   szBuffer [80] ;
      short  i, nLine ;

      for (i = 0 ; i < sizeof info / sizeof info [0] ; i++)
           TextOut (hdc, cxChar, (i + 1) * cyChar, szBuffer,
                sprintf (szBuffer, "%-40s%8d", info[i].szDesc,
                     GetDeviceCaps (hdcInfo, info[i].nIndex))) ;
      }

 void DoOtherInfo (HDC hdc, HDC hdcInfo, short cxChar, short cyChar)
      {
      static BITS clip [] =
           {
           CP_RECTANGLE,  "CP_RECTANGLE",     "Can Clip To Rectangle:"
           } ;

      static BITS raster [] =
           {
           RC_BITBLT,       "RC_BITBLT",       "Capable of simple BitBlt:",
           RC_BANDING,      "RC_BANDING",      "Requires banding support:",
           RC_SCALING,      "RC_SCALING",      "Requires scaling support:",
           RC_BITMAP64,     "RC_BITMAP64",     "Supports bitmaps >64K:",
           RC_GDI20_OUTPUT, "RC_GDI20_OUTPUT", "Has 2.0 output calls:",
           RC_DI_BITMAP,    "RC_DI_BITMAP",    "Supports DIB to memory:",
           RC_PALETTE,      "RC_PALETTE",      "Supports a palette:",
           RC_DIBTODEV,     "RC_DIBTODEV",     "Supports bitmap conversion:",
           RC_BIGFONT,      "RC_BIGFONT",      "Supports fonts >64K:",
           RC_STRETCHBLT,   "RC_STRETCHBLT",   "Supports StretchBlt:",
           RC_FLOODFILL,    "RC_FLOODFILL",    "Supports FloodFill:"
           } ;

      static char *szTech [] = { "DT_PLOTTER (Vector plotter)",
                                 "DT_RASDISPLAY (Raster display)",
                                 "DT_RASPRINTER (Raster printer)",
                                 "DT_RASCAMERA (Raster camera)",
                                 "DT_CHARSTREAM (Character-stream, PLP)",
                                 "DT_METAFILE (Metafile, VDM)",
                                 "DT_DISPFILE (Display-file)" } ;
      char        szBuffer [80] ;
      short       i ;

      TextOut (hdc, cxChar, cyChar, szBuffer,
           sprintf (szBuffer, "%-24s%04XH",
                "DRIVERVERSION:", GetDeviceCaps (hdcInfo, DRIVERVERSION))) ;

      TextOut (hdc, cxChar, 2 * cyChar, szBuffer,
           sprintf (szBuffer, "%-24s%-40s",
                "TECHNOLOGY:", szTech [GetDeviceCaps (hdcInfo, TECHNOLOGY)]))

      TextOut (hdc, cxChar, 4 * cyChar, szBuffer,
           sprintf (szBuffer, "CLIPCAPS (Clipping capabilities)")) ;

      for (i = 0 ; i < sizeof clip / sizeof clip [0] ; i++)
           TextOut (hdc, 9 * cxChar, (i + 6) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s%-28s %3s",
                     clip[i].szMask, clip[i].szDesc,
                     GetDeviceCaps (hdcInfo, CLIPCAPS) & clip[i].nMask ?
                          "Yes" : "No")) ;

      TextOut (hdc, cxChar, 8 * cyChar, szBuffer,
           sprintf (szBuffer, "RASTERCAPS (Raster capabilities)")) ;

      for (i = 0 ; i < sizeof raster / sizeof raster [0] ; i++)
           TextOut (hdc, 9 * cxChar, (i + 10) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s%-28s %3s",
                     raster[i].szMask, raster[i].szDesc,
                     GetDeviceCaps (hdcInfo, RASTERCAPS) & raster[i].nMask ?
                          "Yes" : "No")) ;
      }

 void DoBitCodedCaps (HDC hdc, HDC hdcInfo, short cxChar, short cyChar,
                      short nType)
      {
      static BITS curves [] =
           {
           CC_CIRCLES,    "CC_CIRCLES",    "circles:",
           CC_PIE,        "CC_PIE",        "pie wedges:",
           CC_CHORD,      "CC_CHORD",      "chord arcs:",
           CC_ELLIPSES,   "CC_ELLIPSES",   "ellipses:",
           CC_WIDE,       "CC_WIDE",       "wide borders:",
           CC_STYLED,     "CC_STYLED",     "styled borders:",
           CC_WIDESTYLED, "CC_WIDESTYLED", "wide and styled borders:",
           CC_INTERIORS,  "CC_INTERIORS",  "interiors:"
           } ;

      static BITS lines [] =
           {
           LC_POLYLINE,   "LC_POLYLINE",   "polyline:",
           LC_MARKER,     "LC_MARKER",     "markers:",
           LC_POLYMARKER, "LC_POLYMARKER", "polymarkers",
           LC_WIDE,       "LC_WIDE",       "wide lines:",
           LC_STYLED,     "LC_STYLED",     "styled lines:",
           LC_WIDESTYLED, "LC_WIDESTYLED", "wide and styled lines:",
           LC_INTERIORS,  "LC_INTERIORS",  "interiors:"
           } ;

      static BITS poly [] =
           {
           PC_POLYGON,    "PC_POLYGON",    "alternate fill polygon:",
           PC_RECTANGLE,  "PC_RECTANGLE",  "rectangle:",
           PC_TRAPEZOID,  "PC_TRAPEZOID",  "winding number fill polygon:",
           PC_SCANLINE,   "PC_SCANLINE",   "scanlines:",
           PC_WIDE,       "PC_WIDE",       "wide borders:",
           PC_STYLED,     "PC_STYLED",     "styled borders:",
           PC_WIDESTYLED, "PC_WIDESTYLED", "wide and styled borders:",
           PC_INTERIORS,  "PC_INTERIORS",  "interiors:"
           } ;

      static BITS text [] =
           {
           TC_OP_CHARACTER, "TC_OP_CHARACTER", "character output precision:",
           TC_OP_STROKE,    "TC_OP_STROKE",    "stroke output precision:",
           TC_CP_STROKE,    "TC_CP_STROKE",    "stroke clip precision:",
           TC_CR_90,        "TC_CP_90",        "90 degree character rotation:"
           TC_CR_ANY,       "TC_CR_ANY",       "any character rotation:",
           TC_SF_X_YINDEP,  "TC_SF_X_YINDEP", "scaling independent of X and Y:
           TC_SA_DOUBLE,    "TC_SA_DOUBLE",   "doubled character for scaling:"
           TC_SA_INTEGER,   "TC_SA_INTEGER",  "integer multiples for scaling:"
           TC_SA_CONTIN,    "TC_SA_CONTIN",  "any multiples for exact scaling:
           TC_EA_DOUBLE,    "TC_EA_DOUBLE",  "double weight characters:",
           TC_IA_ABLE,      "TC_IA_ABLE",    "italicizing:",
           TC_UA_ABLE,      "TC_UA_ABLE",    "underlining:",
           TC_SO_ABLE,      "TC_SO_ABLE",    "strikeouts:",
           TC_RA_ABLE,      "TC_RA_ABLE",    "raster fonts:",
           TC_VA_ABLE,      "TC_VA_ABLE",    "vector fonts:"
           } ;

      static struct
           {
           short nIndex ;
           char  *szTitle ;
           BITS  (*pbits) [] ;
           short nSize ;
           }
           bitinfo [] =
           {
           CURVECAPS,  "CURVCAPS (Curve Capabilities)",
                       (BITS (*)[]) curves, sizeof curves / sizeof curves [0],
           LINECAPS,   "LINECAPS (Line Capabilities)",
                       (BITS (*)[]) lines, sizeof lines / sizeof lines [0],
           POLYGONALCAPS, "POLYGONALCAPS (Polygonal Capabilities)",
                       (BITS (*)[]) poly, sizeof poly / sizeof poly [0],
           TEXTCAPS,   "TEXTCAPS (Text Capabilities)",
                       (BITS (*)[]) text, sizeof text / sizeof text [0]
           } ;

      static char szBuffer [80] ;
      BITS        (*pbits) [] = bitinfo [nType].pbits ;
      short       nDevCaps = GetDeviceCaps (hdcInfo, bitinfo [nType].nIndex) ;
      short       i ;

      TextOut (hdc, cxChar, cyChar, bitinfo [nType].szTitle,
                     strlen (bitinfo [nType].szTitle)) ;

      for (i = 0 ; i < bitinfo [nType].nSize ; i++)
           TextOut (hdc, cxChar, (i + 3) * cyChar, szBuffer,
                sprintf (szBuffer, "%-16s %s %-32s %3s",
                     (*pbits)[i].szMask, "Can do", (*pbits)[i].szDesc,
                     nDevCaps & (*pbits)[i].nMask ? "Yes" : "No")) ;
      }


 DEVCAPS1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP11\DEVCAPS1.C

 /*------------------------------------------------------
    DEVCAPS1.C -- Displays Device Capability Information
                  (c) Charles Petzold, 1990
   ------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "devcaps1.h"

 void DoBasicInfo (HDC, HDC, short, short) ;       // in DEVCAPS.C
 void DoOtherInfo (HDC, HDC, short, short) ;
 void DoBitCodedCaps (HDC, HDC, short, short, short) ;

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "DevCaps" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           !RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Device Capabilities",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 HDC GetPrinterIC ()
      {
      char szPrinter [64] ;
      char *szDevice, *szDriver, *szOutput ;

      GetProfileString ("windows", "device", "", szPrinter, 64) ;

      if ((szDevice = strtok (szPrinter, "," )) &&
          (szDriver = strtok (NULL,      ", ")) &&
          (szOutput = strtok (NULL,      ", ")))

                return CreateIC (szDriver, szDevice, szOutput, NULL) ;

      return NULL ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short cxChar, cyChar, nCurrentDevice = IDM_SCREEN,
                                   nCurrentInfo   = IDM_BASIC ;
      HDC          hdc, hdcInfo ;
      HMENU        hMenu ;
      PAINTSTRUCT  ps ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_COMMAND:
                hMenu = GetMenu (hwnd) ;

                switch (wParam)
                     {
                     case IDM_SCREEN:
                     case IDM_PRINTER:
                          CheckMenuItem (hMenu, nCurrentDevice, MF_UNCHECKED)
                          nCurrentDevice = wParam ;
                          CheckMenuItem (hMenu, nCurrentDevice, MF_CHECKED) ;
                          InvalidateRect (hwnd, NULL, TRUE) ;
                          return 0 ;

                     case IDM_BASIC:
                     case IDM_OTHER:
                     case IDM_CURVE:
                     case IDM_LINE:
                     case IDM_POLY:
                     case IDM_TEXT:
                          CheckMenuItem (hMenu, nCurrentInfo, MF_UNCHECKED) ;
                          nCurrentInfo = wParam ;
                          CheckMenuItem (hMenu, nCurrentInfo, MF_CHECKED) ;
                          InvalidateRect (hwnd, NULL, TRUE) ;
                          return 0 ;
                     }
                break ;

           case WM_DEVMODECHANGE:
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                if (nCurrentDevice == IDM_SCREEN)
                     hdcInfo = CreateIC ("DISPLAY", NULL, NULL, NULL) ;
                else
                     hdcInfo = GetPrinterIC () ;

                if (hdcInfo)
                     {
                     switch (nCurrentInfo)
                          {
                          case IDM_BASIC:
                               DoBasicInfo (hdc, hdcInfo, cxChar, cyChar) ;
                               break ;

                          case IDM_OTHER:
                               DoOtherInfo (hdc, hdcInfo, cxChar, cyChar) ;
                               break ;

                          case IDM_CURVE:
                          case IDM_LINE:
                          case IDM_POLY:
                          case IDM_TEXT:
                               DoBitCodedCaps (hdc, hdcInfo, cxChar, cyChar,
                                               nCurrentInfo - IDM_CURVE) ;
                               break ;
                          }
                     DeleteDC (hdcInfo) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 DEVCAPS2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\DEVCAPS2.C

 /*------------------------------------------------------------------
    DEVCAPS2.C -- Displays Device Capability Information (Version 2)
                  (c) Charles Petzold, 1990
   ------------------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "devcaps2.h"

 void DoBasicInfo (HDC, HDC, short, short) ;            // in DEVCAPS.C
 void DoOtherInfo (HDC, HDC, short, short) ;
 void DoBitCodedCaps (HDC, HDC, short, short, short) ;

 typedef VOID (FAR PASCAL *DEVMODEPROC) (HWND, HANDLE, LPSTR, LPSTR) ;

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "DevCaps2" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, NULL,
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void DoEscSupport (HDC hdc, HDC hdcInfo, short cxChar, short cyChar)
      {
      static struct
           {
           char  *szEscCode ;
           short nEscCode ;
           }
           esc [] =
           {
           "NEWFRAME",          NEWFRAME,
           "ABORTDOC",          ABORTDOC,
           "NEXTBAND",          NEXTBAND,
           "SETCOLORTABLE",     SETCOLORTABLE,
           "GETCOLORTABLE",     GETCOLORTABLE,
           "FLUSHOUTPUT",       FLUSHOUTPUT,
           "DRAFTMODE",         DRAFTMODE,
           "QUERYESCSUPPORT",   QUERYESCSUPPORT,
           "SETABORTPROC",      SETABORTPROC,
           "STARTDOC",          STARTDOC,
           "ENDDOC",            ENDDOC,
           "GETPHYSPAGESIZE",   GETPHYSPAGESIZE,
           "GETPRINTINGOFFSET", GETPRINTINGOFFSET,
           "GETSCALINGFACTOR",  GETSCALINGFACTOR } ;

      static char *szYesNo [] = { "Yes", "No" } ;
      char        szBuffer [32] ;
      POINT       pt ;
      short       n, nReturn ;

      TextOut (hdc, cxChar, cyChar, "Escape Support", 14) ;

      for (n = 0 ; n < sizeof esc / sizeof esc [0] ; n++)
           {
           nReturn = Escape (hdcInfo, QUERYESCSUPPORT, 1,
                                    (LPSTR) & esc[n].nEscCode, NULL) ;
           TextOut (hdc, 6 * cxChar, (n + 3) * cyChar, szBuffer,
                wsprintf (szBuffer, "%-24s %3s", (LPSTR) esc[n].szEscCode,
                          (LPSTR) szYesNo [nReturn > 0 ? 0 : 1])) ;

           if (nReturn > 0 && esc[n].nEscCode >= GETPHYSPAGESIZE
                           && esc[n].nEscCode <= GETSCALINGFACTOR)
                {
                Escape (hdcInfo, esc[n].nEscCode, 0, NULL, (LPSTR) &pt) ;
                TextOut (hdc, 36 * cxChar, (n + 3) * cyChar, szBuffer,
                         wsprintf (szBuffer, "(%u,%u)", pt.x, pt.y)) ;
                }
           }
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char   szAllDevices [4096], szDevice [32], szDriver [16],
                    szDriverFile [16], szWindowText [64] ;
      static HANDLE hLibrary ;
      static short  n, cxChar, cyChar, nCurrentDevice = IDM_SCREEN,
                                       nCurrentInfo   = IDM_BASIC ;
      char          *szOutput, *szPtr ;
      DEVMODEPROC   lpfnDM ;
      HDC           hdc, hdcInfo ;
      HMENU         hMenu ;
      PAINTSTRUCT   ps ;
      TEXTMETRIC    tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;
                ReleaseDC (hwnd, hdc) ;

                lParam = NULL ;
                                                   // fall through
           case WM_WININICHANGE:
                if (lParam != NULL && lstrcmp ((LPSTR) lParam, "devices") != 0
                     return 0 ;

                hMenu = GetSubMenu (GetMenu (hwnd), 0) ;

                while (GetMenuItemCount (hMenu) > 1)
                     DeleteMenu (hMenu, 1, MF_BYPOSITION) ;

                GetProfileString ("devices", NULL, "", szAllDevices,
                          sizeof szAllDevices) ;

                n = IDM_SCREEN + 1 ;
                szPtr = szAllDevices ;
                while (*szPtr)
                     {
                     AppendMenu (hMenu, n % 16 ? 0 : MF_MENUBARBREAK, n, szPtr
                     n++ ;
                     szPtr += strlen (szPtr) + 1 ;
                     }
                AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
                AppendMenu (hMenu, 0, IDM_DEVMODE, "Device Mode") ;

                wParam = IDM_SCREEN ;
                                                   // fall through
           case WM_COMMAND:
                hMenu = GetMenu (hwnd) ;

                if (wParam < IDM_DEVMODE)          // IDM_SCREEN & Printers
                     {
                     CheckMenuItem (hMenu, nCurrentDevice, MF_UNCHECKED) ;
                     nCurrentDevice = wParam ;
                     CheckMenuItem (hMenu, nCurrentDevice, MF_CHECKED) ;
                     }
                else if (wParam == IDM_DEVMODE)
                     {
                     GetMenuString (hMenu, nCurrentDevice, szDevice,
                                    sizeof szDevice, MF_BYCOMMAND) ;

                     GetProfileString ("devices", szDevice, "",
                                       szDriver, sizeof szDriver) ;

                     szOutput = strtok (szDriver, ", ") ;
                     strcat (strcpy (szDriverFile, szDriver), ".DRV") ;

                     if (hLibrary >= 32)
                          FreeLibrary (hLibrary) ;

                     hLibrary = LoadLibrary (szDriverFile) ;
                     if (hLibrary >= 32)
                          {
                          lpfnDM = GetProcAddress (hLibrary, "DEVICEMODE") ;
                          (*lpfnDM) (hwnd, hLibrary, (LPSTR) szDevice,
                                                     (LPSTR) szOutput) ;
                          }
                     }
                else                               // info menu items
                     {
                     CheckMenuItem (hMenu, nCurrentInfo, MF_UNCHECKED) ;
                     nCurrentInfo = wParam ;
                     CheckMenuItem (hMenu, nCurrentInfo, MF_CHECKED) ;
                     }
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_INITMENUPOPUP:
                if (lParam == 0)
                     EnableMenuItem (GetMenu (hwnd), IDM_DEVMODE,
                          nCurrentDevice == IDM_SCREEN ?
                               MF_GRAYED : MF_ENABLED) ;
                return 0 ;

           case WM_PAINT:
                strcpy (szWindowText, "Device Capabilities: ") ;

                if (nCurrentDevice == IDM_SCREEN)
                     {
                     strcpy (szDriver, "DISPLAY") ;
                     strcat (szWindowText, szDriver) ;
                     hdcInfo = CreateIC (szDriver, NULL, NULL, NULL) ;
                     }
                else
                     {
                     hMenu = GetMenu (hwnd) ;

                     GetMenuString (hMenu, nCurrentDevice, szDevice,
                                    sizeof szDevice, MF_BYCOMMAND) ;

                     GetProfileString ("devices", szDevice, "", szDriver, 10)
                     szOutput = strtok (szDriver, ", ") ;
                     strcat (szWindowText, szDevice) ;

                     hdcInfo = CreateIC (szDriver, szDevice, szOutput, NULL) ;
                     }
                SetWindowText (hwnd, szWindowText) ;

                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                if (hdcInfo)
                     {
                     switch (nCurrentInfo)
                          {
                          case IDM_BASIC:
                               DoBasicInfo (hdc, hdcInfo, cxChar, cyChar) ;
                               break ;

                          case IDM_OTHER:
                               DoOtherInfo (hdc, hdcInfo, cxChar, cyChar) ;
                               break ;

                          case IDM_CURVE:
                          case IDM_LINE:
                          case IDM_POLY:
                          case IDM_TEXT:
                               DoBitCodedCaps (hdc, hdcInfo, cxChar, cyChar,
                                    nCurrentInfo - IDM_CURVE) ;
                               break ;

                          case IDM_ESC:
                               DoEscSupport (hdc, hdcInfo, cxChar, cyChar) ;
                               break ;
                          }
                     DeleteDC (hdcInfo) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                if (hLibrary >= 32)
                     FreeLibrary (hLibrary) ;

                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 DIGCLOCK.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP05\DIGCLOCK.C

 /*-----------------------------------------
    DIGCLOCK.C -- Digital Clock Program
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #include <time.h>
 #define ID_TIMER    1

 #define YEAR  (datetime->tm_year % 100)
 #define MONTH (datetime->tm_mon  + 1)
 #define MDAY  (datetime->tm_mday)
 #define WDAY  (datetime->tm_wday)
 #define HOUR  (datetime->tm_hour)
 #define MIN   (datetime->tm_min)
 #define SEC   (datetime->tm_sec)

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);
 void SizeTheWindow (short *, short *, short *, short *) ;

 char  sDate [2], sTime [2], sAMPM [2][5] ;
 int   iDate, iTime ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "DigClock" ;
      HWND        hwnd;
      MSG         msg;
      short       xStart, yStart, xClient, yClient ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

     RegisterClass (&wndclass) ;
           }

      SizeTheWindow (&xStart, &yStart, &xClient, &yClient) ;

      hwnd = CreateWindow (szAppName, szAppName,
                           WS_POPUP | WS_DLGFRAME | WS_SYSMENU,
                           xStart,  yStart,
                           xClient, yClient,
                           NULL, NULL, hInstance, NULL) ;

      if (!SetTimer (hwnd, ID_TIMER, 1000, NULL))
           {
           MessageBox (hwnd, "Too many clocks or timers!", szAppName,
                       MB_ICONEXCLAMATION | MB_OK) ;
           return FALSE ;
           }

      ShowWindow (hwnd, SW_SHOWNOACTIVATE) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam;
      }

 void SizeTheWindow (short *pxStart,  short *pyStart,
                     short *pxClient, short *pyClient)
      {
      HDC        hdc ;
      TEXTMETRIC tm ;

      hdc = CreateIC ("DISPLAY", NULL, NULL, NULL) ;
      GetTextMetrics (hdc, &tm) ;
      DeleteDC (hdc) ;

      *pxClient = 2 * GetSystemMetrics (SM_CXDLGFRAME) + 16*tm.tmAveCharWidth
      *pxStart  =     GetSystemMetrics (SM_CXSCREEN)   - *pxClient ;
      *pyClient = 2 * GetSystemMetrics (SM_CYDLGFRAME) + 2*tm.tmHeight ;
      *pyStart  =     GetSystemMetrics (SM_CYSCREEN)   - *pyClient ;
      }

 void SetInternational (void)
      {
      static char cName [] = "intl" ;

      iDate = GetProfileInt (cName, "iDate", 0) ;
      iTime = GetProfileInt (cName, "iTime", 0) ;

      GetProfileString (cName, "sDate",  "/", sDate,     2) ;
      GetProfileString (cName, "sTime",  ":", sTime,     2) ;
      GetProfileString (cName, "s1159", "AM", sAMPM [0], 5) ;
      GetProfileString (cName, "s2359", "PM", sAMPM [1], 5) ;
      }

 void WndPaint (HWND hwnd, HDC hdc)
      {
      static char szWday[] = "Sun\0Mon\0Tue\0Wed\0Thu\0Fri\0Sat" ;
      char        cBuffer[40] ;
      long        lTime ;
      RECT        rect ;
      short       nLength ;
      struct tm   *datetime ;

      time (&lTime) ;
      datetime = localtime (&lTime) ;

      nLength = wsprintf (cBuffer, "  %s  %d%s%02d%s%02d  \r\n",
                (LPSTR) szWday + 4 * WDAY,
                iDate == 1 ? MDAY  : iDate == 2 ? YEAR  : MONTH, (LPSTR) sDate
                iDate == 1 ? MONTH : iDate == 2 ? MONTH : MDAY,  (LPSTR) sDate
                iDate == 1 ? YEAR  : iDate == 2 ? MDAY  : YEAR) ;

      if (iTime == 1)
           nLength += wsprintf (cBuffer + nLength, "  %02d%s%02d%s%02d  ",
                                HOUR, (LPSTR) sTime, MIN, (LPSTR) sTime, SEC)
      else
           nLength += wsprintf (cBuffer + nLength, "  %d%s%02d%s%02d %s  ",
                                (HOUR % 12) ? (HOUR % 12) : 12,
                                (LPSTR) sTime, MIN, (LPSTR) sTime, SEC,
                                (LPSTR) sAMPM [HOUR / 12]) ;

      GetClientRect (hwnd, &rect) ;
      DrawText (hdc, cBuffer, -1, &rect, DT_CENTER | DT_NOCLIP) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      HDC         hdc ;
      PAINTSTRUCT ps;

      switch (message)
           {
           case WM_CREATE :
                SetInternational () ;
                return 0 ;

           case WM_TIMER :
                InvalidateRect (hwnd, NULL, FALSE) ;
                return 0 ;

           case WM_PAINT :
                hdc = BeginPaint (hwnd, &ps) ;
                WndPaint (hwnd, hdc) ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_WININICHANGE :
                SetInternational () ;
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_DESTROY :
                KillTimer (hwnd, ID_TIMER) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 ENVIRON.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP06\ENVIRON.C

 /*----------------------------------------
    ENVIRON.C -- Environment List Box
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>
 #include <string.h>
 #define  MAXENV  4096

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Environ" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = COLOR_WINDOW + 1 ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Environment List Box",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char szBuffer [MAXENV + 1] ;
      static HWND hwndList, hwndText ;
      HDC         hdc ;
      TEXTMETRIC  tm ;
      WORD        n ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                GetTextMetrics (hdc, &tm) ;
                ReleaseDC (hwnd, hdc) ;

                hwndList = CreateWindow ("listbox", NULL,
                               WS_CHILD | WS_VISIBLE | LBS_STANDARD,
                               tm.tmAveCharWidth, tm.tmHeight * 3,
                               tm.tmAveCharWidth * 16 +
                                    GetSystemMetrics (SM_CXVSCROLL),
                               tm.tmHeight * 5,
                               hwnd, 1,
                               GetWindowWord (hwnd, GWW_HINSTANCE), NULL) ;

                hwndText = CreateWindow ("static", NULL,
                               WS_CHILD | WS_VISIBLE | SS_LEFT,
                               tm.tmAveCharWidth,          tm.tmHeight,
                               tm.tmAveCharWidth * MAXENV, tm.tmHeight,
                               hwnd, 2,
                               GetWindowWord (hwnd, GWW_HINSTANCE), NULL) ;

                for (n = 0 ; environ[n] ; n++)
                     {
                     if (strlen (environ [n]) > MAXENV)
                          continue ;
                     *strchr (strcpy (szBuffer, environ [n]), '=') = '\0' ;
                     SendMessage (hwndList, LB_ADDSTRING, 0,
                                  (LONG) (LPSTR) szBuffer) ;
                     }
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndList) ;
                return 0 ;

           case WM_COMMAND:
                if (wParam == 1 && HIWORD (lParam) == LBN_SELCHANGE)
                     {
                     n = (WORD) SendMessage (hwndList, LB_GETCURSEL, 0, 0L) ;
                     n = (WORD) SendMessage (hwndList, LB_GETTEXT, n,
                                             (LONG) (LPSTR) szBuffer) ;

                     strcpy (szBuffer + n + 1, getenv (szBuffer)) ;
                     *(szBuffer + n) = '=' ;

                     SetWindowText (hwndText, szBuffer) ;
                     }
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 FILEDLG.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\FILEDLG.C

 /*-----------------------------------------------
    FILEDLG.C -- Open and Close File Dialog Boxes
   -----------------------------------------------*/

 #include <windows.h>
 #include "filedlg.h"

 BOOL FAR PASCAL FileOpenDlgProc (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL FileSaveDlgProc (HWND, WORD, WORD, LONG) ;

 LPSTR lstrchr  (LPSTR str, char ch) ;
 LPSTR lstrrchr (LPSTR str, char ch) ;

 static char      szDefExt   [5]  ;
 static char      szFileName [96] ;
 static char      szFileSpec [16] ;
 static POFSTRUCT pof ;
 static WORD      wFileAttr, wStatus ;

 int DoFileOpenDlg (HANDLE hInst, HWND hwnd, char *szFileSpecIn,
                    char *szDefExtIn, WORD wFileAttrIn,
                    char *szFileNameOut, POFSTRUCT pofIn)
      {
      FARPROC lpfnFileOpenDlgProc ;
      int     iReturn ;

      lstrcpy (szFileSpec, szFileSpecIn) ;
      lstrcpy (szDefExt,   szDefExtIn) ;
      wFileAttr = wFileAttrIn ;
      pof = pofIn ;

      lpfnFileOpenDlgProc = MakeProcInstance (FileOpenDlgProc, hInst) ;

      iReturn = DialogBox (hInst, "FileOpen", hwnd, lpfnFileOpenDlgProc) ;

      FreeProcInstance (lpfnFileOpenDlgProc) ;

      lstrcpy (szFileNameOut, szFileName) ;
      return iReturn ;
      }

 int DoFileSaveDlg (HANDLE hInst, HWND hwnd, char *szFileSpecIn,
                    char *szDefExtIn, WORD *pwStatusOut,
                    char *szFileNameOut, POFSTRUCT pofIn)
      {
      FARPROC lpfnFileSaveDlgProc ;
      int     iReturn ;

      lstrcpy (szFileSpec, szFileSpecIn) ;
      lstrcpy (szDefExt,   szDefExtIn) ;
      pof = pofIn ;

      lpfnFileSaveDlgProc = MakeProcInstance (FileSaveDlgProc, hInst) ;

      iReturn = DialogBox (hInst, "FileSave", hwnd, lpfnFileSaveDlgProc) ;

      FreeProcInstance (lpfnFileSaveDlgProc) ;

      lstrcpy (szFileNameOut, szFileName) ;
      *pwStatusOut = wStatus ;
      return iReturn ;
      }

 BOOL FAR PASCAL FileOpenDlgProc (HWND hDlg, WORD message,
                                  WORD wParam, LONG lParam)
      {
      char  cLastChar ;
      short nEditLen ;

      switch (message)
         {
         case WM_INITDIALOG:
            SendDlgItemMessage (hDlg, IDD_FNAME, EM_LIMITTEXT, 80, 0L) ;
            DlgDirList (hDlg, szFileSpec, IDD_FLIST, IDD_FPATH, wFileAttr) ;
            SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
            return TRUE ;

         case WM_COMMAND:
            switch (wParam)
               {
               case IDD_FLIST:
                  switch (HIWORD (lParam))
                     {
                     case LBN_SELCHANGE:
                        if (DlgDirSelect (hDlg, szFileName, IDD_FLIST))
                           lstrcat (szFileName, szFileSpec) ;
                        SetDlgItemText (hDlg, IDD_FNAME, szFileName) ;
                        return TRUE ;

                     case LBN_DBLCLK:
                        if (DlgDirSelect (hDlg, szFileName, IDD_FLIST))
                           {
                           lstrcat (szFileName, szFileSpec) ;
                           DlgDirList (hDlg, szFileName, IDD_FLIST, IDD_FPATH,
                                                               wFileAttr) ;
                           SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                           }
                        else
                           {
                           SetDlgItemText (hDlg, IDD_FNAME, szFileName) ;
                           SendMessage (hDlg, WM_COMMAND, IDOK, 0L) ;
                           }
                        return TRUE ;
                     }
                  break ;

               case IDD_FNAME:
                  if (HIWORD (lParam) == EN_CHANGE)
                     EnableWindow (GetDlgItem (hDlg, IDOK),
                        (BOOL) SendMessage (LOWORD (lParam),
                                              WM_GETTEXTLENGTH, 0, 0L)) ;
                  return TRUE ;

               case IDOK:
                  GetDlgItemText (hDlg, IDD_FNAME, szFileName, 80) ;

                  nEditLen  = lstrlen (szFileName) ;
                  cLastChar = *AnsiPrev (szFileName, szFileName + nEditLen) ;

                  if (cLastChar == '\\' || cLastChar == ':')
                     lstrcat (szFileName, szFileSpec) ;

                  if (lstrchr (szFileName, '*') || lstrchr (szFileName, '?'))
                     {
                     if (DlgDirList (hDlg, szFileName, IDD_FLIST,
                                           IDD_FPATH, wFileAttr))
                        {
                        lstrcpy (szFileSpec, szFileName) ;
                        SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                        }
                     else
                        MessageBeep (0) ;

                     return TRUE ;
                     }

                  lstrcat (lstrcat (szFileName, "\\"), szFileSpec) ;

                  if (DlgDirList (hDlg, szFileName, IDD_FLIST,
                                                    IDD_FPATH, wFileAttr))
                     {
                     lstrcpy (szFileSpec, szFileName) ;
                     SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                     return TRUE ;
                     }

                  szFileName [nEditLen] = '\0' ;

                  if (-1 == OpenFile (szFileName, pof, OF_READ | OF_EXIST))
                     {
                     lstrcat (szFileName, szDefExt) ;
                     if (-1 == OpenFile (szFileName, pof, OF_READ | OF_EXIST))
                        {
                        MessageBeep (0) ;
                        return TRUE ;
                        }
                     }
                  lstrcpy (szFileName,
                           AnsiNext (lstrrchr (pof->szPathName, '\\'))) ;

                  OemToAnsi (szFileName, szFileName) ;
                  EndDialog (hDlg, TRUE) ;
                  return TRUE ;

               case IDCANCEL:
                  EndDialog (hDlg, FALSE) ;
                  return TRUE ;
               }
         }
      return FALSE ;
      }

 BOOL FAR PASCAL FileSaveDlgProc (HWND hDlg, WORD message,
                                  WORD wParam, LONG lParam)
      {
      switch (message)
         {
         case WM_INITDIALOG:
            SendDlgItemMessage (hDlg, IDD_FNAME, EM_LIMITTEXT, 80, 0L) ;
            DlgDirList (hDlg, szFileSpec, 0, IDD_FPATH, 0) ;
            SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
            return TRUE ;

         case WM_COMMAND:
            switch (wParam)
               {
               case IDD_FNAME:
                  if (HIWORD (lParam) == EN_CHANGE)
                     EnableWindow (GetDlgItem (hDlg, IDOK),
                        (BOOL) SendMessage (LOWORD (lParam),
                                              WM_GETTEXTLENGTH, 0, 0L)) ;
                  return TRUE ;

               case IDOK:
                  GetDlgItemText (hDlg, IDD_FNAME, szFileName, 80) ;

                  if (-1 == OpenFile (szFileName, pof, OF_PARSE))
                     {
                     MessageBeep (0) ;
                     return TRUE ;
                     }

                  if (!lstrchr (AnsiNext (lstrrchr (pof->szPathName, '\\')),
                                '.'))
                     lstrcat (szFileName, szDefExt) ;

                  if (-1 != OpenFile (szFileName, pof, OF_WRITE | OF_EXIST))
                     wStatus = 1 ;

                  else if (-1 != OpenFile (szFileName, pof,
                                                   OF_CREATE | OF_EXIST))
                     wStatus = 0 ;

                  else
                     {
                     MessageBeep (0) ;
                     return TRUE ;
                     }

                  lstrcpy (szFileName,
                           AnsiNext (lstrrchr (pof->szPathName, '\\'))) ;

                  OemToAnsi (szFileName, szFileName) ;
                  EndDialog (hDlg, TRUE) ;
                  return TRUE ;

               case IDCANCEL:
                  EndDialog (hDlg, FALSE) ;
                  return TRUE ;
               }
         }
      return FALSE ;
      }

 LPSTR lstrchr (LPSTR str, char ch)
      {
      while (*str)
           {
           if (ch == *str)
                return str ;

           str = AnsiNext (str) ;
           }
      return NULL ;
      }

 LPSTR lstrrchr (LPSTR str, char ch)
      {
      LPSTR strl = str + lstrlen (str) ;

      do
           {
           if (ch == *strl)
                return strl ;

           strl = AnsiPrev (str, strl) ;
           }
      while (strl > str) ;

      return NULL ;
      }


 FILEDLG.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\FILEDLG.C

 /*-----------------------------------------------
    FILEDLG.C -- Open and Close File Dialog Boxes
   -----------------------------------------------*/

 #include <windows.h>
 #include "filedlg.h"

 BOOL FAR PASCAL FileOpenDlgProc (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL FileSaveDlgProc (HWND, WORD, WORD, LONG) ;

 LPSTR lstrchr  (LPSTR str, char ch) ;
 LPSTR lstrrchr (LPSTR str, char ch) ;

 static char      szDefExt   [5]  ;
 static char      szFileName [96] ;
 static char      szFileSpec [16] ;
 static POFSTRUCT pof ;
 static WORD      wFileAttr, wStatus ;

 int DoFileOpenDlg (HANDLE hInst, HWND hwnd, char *szFileSpecIn,
                    char *szDefExtIn, WORD wFileAttrIn,
                    char *szFileNameOut, POFSTRUCT pofIn)
      {
      FARPROC lpfnFileOpenDlgProc ;
      int     iReturn ;

      lstrcpy (szFileSpec, szFileSpecIn) ;
      lstrcpy (szDefExt,   szDefExtIn) ;
      wFileAttr = wFileAttrIn ;
      pof = pofIn ;

      lpfnFileOpenDlgProc = MakeProcInstance (FileOpenDlgProc, hInst) ;

      iReturn = DialogBox (hInst, "FileOpen", hwnd, lpfnFileOpenDlgProc) ;

      FreeProcInstance (lpfnFileOpenDlgProc) ;

      lstrcpy (szFileNameOut, szFileName) ;
      return iReturn ;
      }

 int DoFileSaveDlg (HANDLE hInst, HWND hwnd, char *szFileSpecIn,
                    char *szDefExtIn, WORD *pwStatusOut,
                    char *szFileNameOut, POFSTRUCT pofIn)
      {
      FARPROC lpfnFileSaveDlgProc ;
      int     iReturn ;

      lstrcpy (szFileSpec, szFileSpecIn) ;
      lstrcpy (szDefExt,   szDefExtIn) ;
      pof = pofIn ;

      lpfnFileSaveDlgProc = MakeProcInstance (FileSaveDlgProc, hInst) ;

      iReturn = DialogBox (hInst, "FileSave", hwnd, lpfnFileSaveDlgProc) ;

      FreeProcInstance (lpfnFileSaveDlgProc) ;

      lstrcpy (szFileNameOut, szFileName) ;
      *pwStatusOut = wStatus ;
      return iReturn ;
      }

 BOOL FAR PASCAL FileOpenDlgProc (HWND hDlg, WORD message,
                                  WORD wParam, LONG lParam)
      {
      char  cLastChar ;
      short nEditLen ;

      switch (message)
         {
         case WM_INITDIALOG:
            SendDlgItemMessage (hDlg, IDD_FNAME, EM_LIMITTEXT, 80, 0L) ;
            DlgDirList (hDlg, szFileSpec, IDD_FLIST, IDD_FPATH, wFileAttr) ;
            SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
            return TRUE ;

         case WM_COMMAND:
            switch (wParam)
               {
               case IDD_FLIST:
                  switch (HIWORD (lParam))
                     {
                     case LBN_SELCHANGE:
                        if (DlgDirSelect (hDlg, szFileName, IDD_FLIST))
                           lstrcat (szFileName, szFileSpec) ;
                        SetDlgItemText (hDlg, IDD_FNAME, szFileName) ;
                        return TRUE ;

                     case LBN_DBLCLK:
                        if (DlgDirSelect (hDlg, szFileName, IDD_FLIST))
                           {
                           lstrcat (szFileName, szFileSpec) ;
                           DlgDirList (hDlg, szFileName, IDD_FLIST, IDD_FPATH,
                                                               wFileAttr) ;
                           SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                           }
                        else
                           {
                           SetDlgItemText (hDlg, IDD_FNAME, szFileName) ;
                           SendMessage (hDlg, WM_COMMAND, IDOK, 0L) ;
                           }
                        return TRUE ;
                     }
                  break ;

               case IDD_FNAME:
                  if (HIWORD (lParam) == EN_CHANGE)
                     EnableWindow (GetDlgItem (hDlg, IDOK),
                        (BOOL) SendMessage (LOWORD (lParam),
                                              WM_GETTEXTLENGTH, 0, 0L)) ;
                  return TRUE ;

               case IDOK:
                  GetDlgItemText (hDlg, IDD_FNAME, szFileName, 80) ;

                  nEditLen  = lstrlen (szFileName) ;
                  cLastChar = *AnsiPrev (szFileName, szFileName + nEditLen) ;

                  if (cLastChar == '\\' || cLastChar == ':')
                     lstrcat (szFileName, szFileSpec) ;

                  if (lstrchr (szFileName, '*') || lstrchr (szFileName, '?'))
                     {
                     if (DlgDirList (hDlg, szFileName, IDD_FLIST,
                                           IDD_FPATH, wFileAttr))
                        {
                        lstrcpy (szFileSpec, szFileName) ;
                        SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                        }
                     else
                        MessageBeep (0) ;

                     return TRUE ;
                     }

                  lstrcat (lstrcat (szFileName, "\\"), szFileSpec) ;

                  if (DlgDirList (hDlg, szFileName, IDD_FLIST,
                                                    IDD_FPATH, wFileAttr))
                     {
                     lstrcpy (szFileSpec, szFileName) ;
                     SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
                     return TRUE ;
                     }

                  szFileName [nEditLen] = '\0' ;

                  if (-1 == OpenFile (szFileName, pof, OF_READ | OF_EXIST))
                     {
                     lstrcat (szFileName, szDefExt) ;
                     if (-1 == OpenFile (szFileName, pof, OF_READ | OF_EXIST))
                        {
                        MessageBeep (0) ;
                        return TRUE ;
                        }
                     }
                     lstrcpy (szFileName,
                              AnsiNext (lstrrchr (pof->szPathName, '\\'))) ;

                  OemToAnsi (szFileName, szFileName) ;
                  EndDialog (hDlg, TRUE) ;
                  return TRUE ;

               case IDCANCEL:
                  EndDialog (hDlg, FALSE) ;
                  return TRUE ;
               }
         }
      return FALSE ;
      }

 BOOL FAR PASCAL FileSaveDlgProc (HWND hDlg, WORD message,
                                  WORD wParam, LONG lParam)
      {
      switch (message)
         {
         case WM_INITDIALOG:
            SendDlgItemMessage (hDlg, IDD_FNAME, EM_LIMITTEXT, 80, 0L) ;
            DlgDirList (hDlg, szFileSpec, 0, IDD_FPATH, 0) ;
            SetDlgItemText (hDlg, IDD_FNAME, szFileSpec) ;
            return TRUE ;

         case WM_COMMAND:
            switch (wParam)
               {
               case IDD_FNAME:
                  if (HIWORD (lParam) == EN_CHANGE)
                     EnableWindow (GetDlgItem (hDlg, IDOK),
                        (BOOL) SendMessage (LOWORD (lParam),
                                              WM_GETTEXTLENGTH, 0, 0L)) ;
                  return TRUE ;

               case IDOK:
                  GetDlgItemText (hDlg, IDD_FNAME, szFileName, 80) ;

                  if (-1 == OpenFile (szFileName, pof, OF_PARSE))
                     {
                     MessageBeep (0) ;
                     return TRUE ;
                     }

                  if (!lstrchr (AnsiNext (lstrrchr (pof->szPathName, '\\')),
                                '.'))
                     lstrcat (szFileName, szDefExt) ;

                  if (-1 != OpenFile (szFileName, pof, OF_WRITE | OF_EXIST))
                     wStatus = 1 ;

                  else if (-1 != OpenFile (szFileName, pof,
                                                   OF_CREATE | OF_EXIST))
                     wStatus = 0 ;

                  else
                     {
                     MessageBeep (0) ;
                     return TRUE ;
                     }

                  lstrcpy (szFileName,
                           AnsiNext (lstrrchr (pof->szPathName, '\\'))) ;

                  OemToAnsi (szFileName, szFileName) ;
                  EndDialog (hDlg, TRUE) ;
                  return TRUE ;

               case IDCANCEL:
                  EndDialog (hDlg, FALSE) ;
                  return TRUE ;
               }
         }
      return FALSE ;
      }

 LPSTR lstrchr (LPSTR str, char ch)
      {
      while (*str)
           {
           if (ch == *str)
                return str ;

           str = AnsiNext (str) ;
           }
      return NULL ;
      }

 LPSTR lstrrchr (LPSTR str, char ch)
      {
      LPSTR strl = str + lstrlen (str) ;

      do
           {
           if (ch == *strl)
                return strl ;

           strl = AnsiPrev (str, strl) ;
           }
      while (strl > str) ;

      return NULL ;
      }


 FONTLIST.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP14\FONTLIST.C

 /*-----------------------------------------
    FONTLIST.C -- Font Enumeration Program
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "fontlist.h"

 typedef struct
      {
      GLOBALHANDLE hGMem ;
      short        nCount ;
      }
      ENUMER ;

 typedef struct
      {
      short        nFontType ;
      LOGFONT      lf ;
      TEXTMETRIC   tm ;
      }
      FONT ;

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 int  FAR PASCAL EnumAllFaces (LPLOGFONT, LPTEXTMETRIC, short, ENUMER FAR *) ;
 int  FAR PASCAL EnumAllFonts (LPLOGFONT, LPTEXTMETRIC, short, ENUMER FAR *) ;

 char szAppName[] = "FontList" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }
      hwnd = CreateWindow (szAppName, "Font Enumeration",
                           WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 int FAR PASCAL EnumAllFaces (LPLOGFONT lf, LPTEXTMETRIC tm,
                              short nFontType, ENUMER FAR *enumer)
      {
      LPSTR lpFaces ;

      if (NULL == GlobalReAlloc (enumer->hGMem,
                          (DWORD) LF_FACESIZE * (1 + enumer->nCount),
                          GMEM_MOVEABLE))
           return 0 ;

      lpFaces = GlobalLock (enumer->hGMem) ;
      lstrcpy (lpFaces + enumer->nCount * LF_FACESIZE, lf->lfFaceName) ;
      GlobalUnlock (enumer->hGMem) ;
      enumer->nCount ++ ;
      return 1 ;
      }

 int FAR PASCAL EnumAllFonts (LPLOGFONT lf, LPTEXTMETRIC tm,
                              short nFontType, ENUMER FAR *enumer)
      {
      FONT FAR *font ;

      if (NULL == GlobalReAlloc (enumer->hGMem,
                          (DWORD) sizeof (FONT) * (1 + enumer->nCount),
                          GMEM_MOVEABLE))
           return 0 ;

      font = (FONT FAR *) GlobalLock (enumer->hGMem) + enumer->nCount ;
      font->nFontType = nFontType ;
      font->lf = *lf ;
      font->tm = *tm ;

      GlobalUnlock (enumer->hGMem) ;
      enumer->nCount ++ ;
      return 1 ;
      }

 void Display (HDC hdc, short cxChar, short cyChar, FONT FAR *font)
      {
      static FONT f ;

      static char *szYN [] = { "No",         "Yes" } ;
      static char *szCS [] = { "ANSI",       "?????",   "Kanji",    "OEM" } ;
      static char *szOP [] = { "Default",    "String",  "Char",    "Stroke" }
      static char *szCP [] = { "Default",    "Char",    "Stroke",   "?????" }
      static char *szQU [] = { "Draft",      "Default", "Proof",    "?????" }
      static char *szP1 [] = { "Default",    "Fixed",   "Variable", "?????" }
      static char *szP2 [] = { "Fixed",      "Variable" } ;
      static char *szFA [] = { "Don't Care", "Roman",      "Swiss", "Modern",
                               "Script",     "Decorative", "?????", "?????" }
      static char *szVR [] = { "Stroke",     "Raster" } ;
      static char *szGD [] = { "GDI",        "Device" } ;

      static struct
           {
           short x ;
           short y ;
           char  *szFmt ;
           short *pData ;
           }
           shorts [] =
           {
            1,  1, "LOGFONT",            NULL,
            1,  2, "-------",            NULL,
            1,  3, "Height:      %10d",  &f.lf.lfHeight,
            1,  4, "Width:       %10d",  &f.lf.lfWidth,
            1,  5, "Escapement:  %10d",  &f.lf.lfEscapement,
            1,  6, "Orientation: %10d",  &f.lf.lfOrientation,
            1,  7, "Weight:      %10d",  &f.lf.lfWeight,
           28,  1, "TEXTMETRIC",         NULL,
           28,  2, "----------",         NULL,
           28,  3, "Height:       %5d",  &f.tm.tmHeight,
           28,  4, "Ascent:       %5d",  &f.tm.tmAscent,
           28,  5, "Descent:      %5d",  &f.tm.tmDescent,
           28,  6, "Int. Leading: %5d",  &f.tm.tmInternalLeading,
           28,  7, "Ext. Leading: %5d",  &f.tm.tmExternalLeading,
           28,  8, "Ave. Width:   %5d",  &f.tm.tmAveCharWidth,
           28,  9, "Max. Width:   %5d",  &f.tm.tmMaxCharWidth,
           28, 10, "Weight:       %5d",  &f.tm.tmWeight,
           51, 10, "Overhang:     %10d", &f.tm.tmOverhang,
           51, 11, "Digitized X:  %10d", &f.tm.tmDigitizedAspectX,
           51, 12, "Digitized Y:  %10d", &f.tm.tmDigitizedAspectY
           } ;

      static struct
           {
           short x ;
           short y ;
           char  *szFmt ;
           BYTE  *pData ;
           }
           bytes [] =
           {
           51,  3, "First Char:   %10d", &f.tm.tmFirstChar,
           51,  4, "Last Char:    %10d", &f.tm.tmLastChar,
           51,  5, "Default Char: %10d", &f.tm.tmDefaultChar,
           51,  6, "Break Char:   %10d", &f.tm.tmBreakChar
           } ;

      static struct
           {
           short x ;
           short y ;
           char  *szFmt ;
           BYTE  *pData ;
           char  **szArray ;
           short sAnd ;
           short sShift ;
           }
           strings [] =
           {
            1,  8, "Italic:      %10s",  &f.lf.lfItalic,         szYN, 1,    0
            1,  9, "Underline:   %10s",  &f.lf.lfUnderline,      szYN, 1,    0
            1, 10, "Strike-Out:  %10s",  &f.lf.lfStrikeOut,      szYN, 1,    0
            1, 11, "Char Set:    %10s",  &f.lf.lfCharSet,        szCS, 0xC0, 6
            1, 12, "Out  Prec:   %10s",  &f.lf.lfOutPrecision,   szOP, 3,    0
            1, 13, "Clip Prec:   %10s",  &f.lf.lfClipPrecision,  szCP, 3,    0
            1, 14, "Quality:     %10s",  &f.lf.lfQuality,        szQU, 3,    0
            1, 15, "Pitch:       %10s",  &f.lf.lfPitchAndFamily, szP1, 3,    0
            1, 16, "Family:      %10s",  &f.lf.lfPitchAndFamily, szFA, 0x70, 4
           28, 11, "Italic:       %5s",  &f.tm.tmItalic,         szYN, 1,    0
           28, 12, "Underline:    %5s",  &f.tm.tmUnderlined,     szYN, 1,    0
           28, 13, "Strike-Out:   %5s",  &f.tm.tmStruckOut,      szYN, 1,    0
           51,  7, "Pitch:        %10s", &f.tm.tmPitchAndFamily, szP2, 1,    0
           51,  8, "Family:       %10s", &f.tm.tmPitchAndFamily, szFA, 0x70, 4
           51,  9, "Char Set:     %10s", &f.tm.tmCharSet,        szCS, 0xC0, 6
           36, 15, "Font Type:  %6s",    (BYTE *) &f.nFontType,  szVR, 1,    0
           55, 15, "%s",                 (BYTE *) &f.nFontType,  szGD, 2,    1
           } ;

      char szBuffer [80] ;
      int  i ;

      f = *font ;

      for (i = 0 ; i < sizeof shorts / sizeof shorts [0] ; i++)
           TextOut (hdc, cxChar * shorts[i].x, cyChar * shorts[i].y, szBuffer,
                    wsprintf (szBuffer, shorts[i].szFmt,
                              *shorts[i].pData)) ;

      for (i = 0 ; i < sizeof bytes / sizeof bytes [0] ; i++)
           TextOut (hdc, cxChar * bytes[i].x, cyChar * bytes[i].y, szBuffer,
                    wsprintf (szBuffer, bytes[i].szFmt,
                              *bytes[i].pData)) ;

      for (i = 0 ; i < sizeof strings / sizeof strings [0] ; i++)
           TextOut (hdc, cxChar * strings[i].x, cyChar * strings[i].y, szBuffe
                    wsprintf (szBuffer, strings[i].szFmt,
                              (LPSTR) ((strings[i].szArray)
                                   [(*strings[i].pData & strings[i].sAnd) >>
                                         strings[i].sShift]))) ;

      TextOut (hdc, cxChar, cyChar * 17, szBuffer,
               wsprintf (szBuffer, "Face Name:   %10s",
                         (LPSTR) f.lf.lfFaceName)) ;
      }

 HDC GetPrinterIC ()
      {
      char szPrinter [64] ;
      char *szDevice, *szDriver, *szOutput ;

      GetProfileString ("windows", "device", "", szPrinter, 64) ;

      if ((szDevice = strtok (szPrinter, "," )) &&
          (szDriver = strtok (NULL,      ", ")) &&
          (szOutput = strtok (NULL,      ", ")))

                return CreateIC (szDriver, szDevice, szOutput, NULL) ;

      return NULL ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL    bHaveInfo = FALSE ;
      static ENUMER  enumer1, enumer2 ;
      static FARPROC lpfnEnumAllFaces, lpfnEnumAllFonts ;
      static short   cxChar, cyChar, nCurrent ;
      static WORD    wCurrentDC = IDM_SCREEN ;
      HANDLE         hInstance ;
      HDC            hdc ;
      HFONT          hFont ;
      HMENU          hMenu ;
      FONT FAR       *font ;
      LPSTR          lpFaces ;
      PAINTSTRUCT    ps ;
      short          i ;
      TEXTMETRIC     tm ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = ((LPCREATESTRUCT) lParam)-> hInstance ;
                lpfnEnumAllFaces = MakeProcInstance (EnumAllFaces, hInstance)
                lpfnEnumAllFonts = MakeProcInstance (EnumAllFonts, hInstance)

                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                GetTextMetrics (hdc, (LPTEXTMETRIC) &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_COMMAND:
                if (wParam == IDM_EXIT)
                     {
                     SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                     return 0 ;
                     }
                else if (wParam == wCurrentDC)
                     return 0 ;

                hMenu = GetMenu (hwnd) ;
                CheckMenuItem (hMenu, wCurrentDC, MF_UNCHECKED) ;
                CheckMenuItem (hMenu, wCurrentDC = wParam, MF_CHECKED) ;

                                         // fall through

           case WM_DEVMODECHANGE:
           case WM_FONTCHANGE:
                bHaveInfo = FALSE ;
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                if (!bHaveInfo)
                     {
                     if (enumer2.hGMem)
                          GlobalFree (enumer2.hGMem) ;

                     enumer1.hGMem  = GlobalAlloc (GHND, 1L) ;
                     enumer1.nCount = 0 ;

                     enumer2.hGMem  = GlobalAlloc (GHND, 1L) ;
                     enumer2.nCount = 0 ;

                     if (NULL == enumer1.hGMem || NULL == enumer2.hGMem)
                          goto MEMORY_ERROR ;

                     if (wCurrentDC == IDM_SCREEN)
                          hdc = CreateIC ("DISPLAY", NULL, NULL, NULL) ;
                     else
                          hdc = GetPrinterIC () ;

                     if (hdc)
                          {
                          if (0 == EnumFonts (hdc, NULL, lpfnEnumAllFaces,
                                                   (LPSTR) &enumer1))
                               goto MEMORY_ERROR ;

                          lpFaces = GlobalLock (enumer1.hGMem) ;

                          for (i = 0 ; i < enumer1.nCount ; i++)
                               if (0 == EnumFonts (hdc,
                                              lpFaces + i * LF_FACESIZE,
                                              lpfnEnumAllFonts,
                                              (LPSTR) &enumer2))
                                    goto MEMORY_ERROR ;

                          GlobalUnlock (enumer1.hGMem) ;
                          enumer2.nCount-- ;

                          DeleteDC (hdc) ;
                          bHaveInfo = TRUE ;
                          }
                     GlobalFree (enumer1.hGMem) ;
                     SetScrollRange (hwnd, SB_VERT, 0, enumer2.nCount, FALSE)
                     SetScrollPos   (hwnd, SB_VERT, nCurrent = 0, TRUE) ;
                     }

                hdc = BeginPaint (hwnd, &ps) ;

                if (bHaveInfo)
                     {
                     SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                     font = (FONT FAR *) GlobalLock (enumer2.hGMem) + nCurrent
                     Display (hdc, cxChar, cyChar, font) ;

                     hFont = SelectObject (hdc, CreateFontIndirect (&font->lf)

                     TextOut (hdc, 1 * cxChar, 19 * cyChar,
                         "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz
                          52) ;

                     GlobalUnlock (enumer2.hGMem) ;
                     DeleteObject (SelectObject (hdc, hFont)) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_KEYDOWN:
                switch (wParam)
                     {
                     case VK_HOME:
                          SendMessage (hwnd, WM_VSCROLL, SB_TOP, 0L) ;
                          break ;
                     case VK_END:
                          SendMessage (hwnd, WM_VSCROLL, SB_BOTTOM, 0L) ;
                          break ;
                     case VK_LEFT:
                     case VK_UP:
                     case VK_PRIOR:
                          SendMessage (hwnd, WM_VSCROLL, SB_LINEUP, 0L) ;
                          break ;
                     case VK_RIGHT:
                     case VK_DOWN:
                     case VK_NEXT:
                          SendMessage (hwnd, WM_VSCROLL, SB_LINEDOWN, 0L) ;
                          break ;
                     default:
                          return 0 ;
                     }
                return 0 ;

           case WM_VSCROLL:
                switch (wParam)
                     {
                     case SB_TOP:
                          nCurrent = 0 ;
                          break ;
                     case SB_BOTTOM:
                          nCurrent = enumer2.nCount ;
                          break ;
                     case SB_LINEUP:
                     case SB_PAGEUP:
                          nCurrent -- ;
                          break ;
                     case SB_LINEDOWN:
                     case SB_PAGEDOWN:
                          nCurrent ++ ;
                          break ;
                     case SB_THUMBPOSITION:
                          nCurrent = LOWORD (lParam) ;
                          break ;
                     default:
                          return 0 ;
                     }
                nCurrent = min (max (0, nCurrent), enumer2.nCount) ;
                SetScrollPos (hwnd, SB_VERT, nCurrent, TRUE) ;
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           MEMORY_ERROR:
                MessageBox (hwnd, "Cannot allocate memory, must end.",
                     szAppName, MB_OK | MB_ICONSTOP | MB_SYSTEMMODAL) ;

                                              // fall through
           case WM_CLOSE:
                DestroyWindow (hwnd) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 FORMFEED.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\FORMFEED.C

 /*---------------------------------------------
    FORMFEED.C -- Advances printer to next page
                  (c) Charles Petzold, 1990
   ---------------------------------------------*/

 #include <windows.h>
 #include <string.h>

 HDC  GetPrinterDC (void) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szMsg [] = "FormFeed" ;
      HDC         hdcPrint ;

      if (hdcPrint = GetPrinterDC ())
           {
           if (Escape (hdcPrint, STARTDOC, sizeof szMsg - 1, szMsg, NULL) > 0)
                if (Escape (hdcPrint, NEWFRAME, 0, NULL, NULL) > 0)
                     Escape (hdcPrint, ENDDOC, 0, NULL, NULL) ;

           DeleteDC (hdcPrint) ;
           }
      return FALSE ;
      }

 HDC GetPrinterDC (void)
      {
      static char szPrinter [80] ;
      char        *szDevice, *szDriver, *szOutput ;

      GetProfileString ("windows", "device", ",,,", szPrinter, 80) ;

      if ((szDevice = strtok (szPrinter, "," )) &&
          (szDriver = strtok (NULL,      ", ")) &&
          (szOutput = strtok (NULL,      ", ")))

                return CreateDC (szDriver, szDevice, szOutput, NULL) ;

      return 0 ;
      }


 FREEMEM.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP05\FREEMEM.C

 /*------------------------------------------
    FREEMEM.C -- Free Memory Display Program
                 (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>
 #include <stdio.h>
 #define ID_TIMER    1

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "FreeMem" ;
      HDC         hdc ;
      HWND        hwnd ;
      MSG         msg ;
      TEXTMETRIC  tm ;
      WNDCLASS    wndclass ;

      if (hPrevInstance)
           return FALSE ;

      wndclass.style         = CS_HREDRAW | CS_VREDRAW;
      wndclass.lpfnWndProc   = WndProc ;
      wndclass.cbClsExtra    = 0 ;
      wndclass.cbWndExtra    = 0 ;
      wndclass.hInstance     = hInstance ;
      wndclass.hIcon         = NULL ;
      wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
      wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
      wndclass.lpszMenuName  = NULL ;
      wndclass.lpszClassName = szAppName ;

      !RegisterClass (&wndclass) ;

      hwnd = CreateWindow (szAppName, "Free Memory",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      hdc = GetDC (hwnd) ;
      GetTextMetrics (hdc, &tm) ;
      ReleaseDC (hwnd, hdc) ;

      if (4 * tm.tmAveCharWidth > GetSystemMetrics (SM_CXICON) ||
                2 * tm.tmHeight > GetSystemMetrics (SM_CYICON))
           {
           MessageBox (hwnd, "Icon size too small for display!",
                       szAppName, MB_ICONEXCLAMATION | MB_OK) ;
           return FALSE ;
           }

      if (!SetTimer (hwnd, ID_TIMER, 1000, NULL))
           {
           MessageBox (hwnd, "Too many clocks or timers!",
                       szAppName, MB_ICONEXCLAMATION | MB_OK) ;
           return FALSE ;
           }

      ShowWindow (hwnd, SW_SHOWMINNOACTIVE) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static DWORD  dwFreeMem, dwPrevMem ;
      static RECT   rect ;
      char          cBuffer [20] ;
      HDC           hdc ;
      PAINTSTRUCT   ps ;

      switch (message)
           {
           case WM_TIMER:
                dwFreeMem = GetFreeSpace (0) ;

                if (dwFreeMem != dwPrevMem)
                     InvalidateRect (hwnd, NULL, TRUE) ;

                dwPrevMem = dwFreeMem ;
                return 0 ;

           case WM_SIZE:
                GetClientRect (hwnd, &rect) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                DrawText (hdc, cBuffer,
                          sprintf (cBuffer, "%.2f megs",
                                   dwFreeMem / 1024.0 / 1024.0),
                          &rect, DT_WORDBREAK) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_QUERYOPEN:
                return 0 ;

           case WM_DESTROY:
                KillTimer (hwnd, ID_TIMER) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 GRAFMENU.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\GRAFMENU.C

 /*----------------------------------------------
    GRAFMENU.C -- Demonstrates Bitmap Menu Items
                  (c) Charles Petzold, 1990
   ----------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "grafmenu.h"

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;
 HBITMAP StretchBitmap (HBITMAP) ;
 HBITMAP GetBitmapFont (int) ;

 char szAppName [] = "GrafMenu" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HBITMAP  hBitmapHelp, hBitmapFile, hBitmapEdit,
               hBitmapFont, hBitmapPopFont [3] ;
      HMENU    hMenu, hMenuPopup ;
      HWND     hwnd ;
      int      i ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hMenu = CreateMenu () ;

      hMenuPopup = LoadMenu (hInstance, "MenuFile") ;
      hBitmapFile = StretchBitmap (LoadBitmap (hInstance, "BitmapFile")) ;
      AppendMenu (hMenu, MF_BITMAP | MF_POPUP, hMenuPopup,
                  (LPSTR) (LONG) hBitmapFile);

      hMenuPopup = LoadMenu (hInstance, "MenuEdit") ;
      hBitmapEdit = StretchBitmap (LoadBitmap (hInstance, "BitmapEdit")) ;
      AppendMenu (hMenu, MF_BITMAP | MF_POPUP, hMenuPopup,
                  (LPSTR) (LONG) hBitmapEdit);

      hMenuPopup = CreateMenu () ;

      for (i = 0 ; i < 3 ; i++)
           {
           hBitmapPopFont [i] = GetBitmapFont (i) ;
           AppendMenu (hMenuPopup, MF_BITMAP, IDM_COUR + i,
                       (LPSTR) (LONG) hBitmapPopFont [i]) ;
           }

      hBitmapFont = StretchBitmap (LoadBitmap (hInstance, "BitmapFont")) ;
      AppendMenu (hMenu, MF_BITMAP | MF_POPUP, hMenuPopup,
                  (LPSTR) (LONG) hBitmapFont);

      hwnd = CreateWindow (szAppName, "Bitmap Menu Demonstration",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, hMenu, hInstance, NULL) ;

      hMenu = GetSystemMenu (hwnd, FALSE);
      hBitmapHelp = StretchBitmap (LoadBitmap (hInstance, "BitmapHelp")) ;
      AppendMenu (hMenu, MF_SEPARATOR, NULL,     NULL) ;
      AppendMenu (hMenu, MF_BITMAP,    IDM_HELP, (LPSTR) (LONG) hBitmapHelp) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }

      DeleteObject (hBitmapHelp) ;
      DeleteObject (hBitmapEdit) ;
      DeleteObject (hBitmapFile) ;
      DeleteObject (hBitmapFont) ;

      for (i = 0 ; i < 3 ; i++)
           DeleteObject (hBitmapPopFont [i]) ;

      return msg.wParam ;
      }

 HBITMAP StretchBitmap (HBITMAP hBitmap1)
      {
      BITMAP     bm1, bm2 ;
      HBITMAP    hBitmap2 ;
      HDC        hdc, hdcMem1, hdcMem2 ;
      TEXTMETRIC tm ;

      hdc = CreateIC ("DISPLAY", NULL, NULL, NULL) ;
      GetTextMetrics (hdc, &tm) ;
      hdcMem1 = CreateCompatibleDC (hdc) ;
      hdcMem2 = CreateCompatibleDC (hdc) ;
      DeleteDC (hdc) ;

      GetObject (hBitmap1, sizeof (BITMAP), (LPSTR) &bm1) ;

      bm2 = bm1 ;
      bm2.bmWidth      = (tm.tmAveCharWidth * bm2.bmWidth)  / 4 ;
      bm2.bmHeight     = (tm.tmHeight       * bm2.bmHeight) / 8 ;
      bm2.bmWidthBytes = ((bm2.bmWidth + 15) / 16) * 2 ;

      hBitmap2 = CreateBitmapIndirect (&bm2) ;

      SelectObject (hdcMem1, hBitmap1) ;
      SelectObject (hdcMem2, hBitmap2) ;

      StretchBlt (hdcMem2, 0, 0, bm2.bmWidth, bm2.bmHeight,
                  hdcMem1, 0, 0, bm1.bmWidth, bm1.bmHeight, SRCCOPY) ;

      DeleteDC (hdcMem1) ;
      DeleteDC (hdcMem2) ;
      DeleteObject (hBitmap1) ;

      return hBitmap2 ;
      }

 HBITMAP GetBitmapFont (int i)
      {
      static  struct
           {
           BYTE lfPitchAndFamily ;
           BYTE lfFaceName [LF_FACESIZE] ;
           char *szMenuText ;
           }
           lfSet [3] =
           {
           FIXED_PITCH    | FF_MODERN, "Courier",   "Courier",
           VARIABLE_PITCH | FF_SWISS,  "Helvetica", "Helvetica",
           VARIABLE_PITCH | FF_ROMAN,  "Tms Rmn",   "Times Roman"
           } ;
      DWORD   dwSize ;
      HBITMAP hBitmap ;
      HDC     hdc, hdcMem ;
      HFONT   hFont ;
      LOGFONT lf ;

      hFont = GetStockObject (SYSTEM_FONT) ;
      GetObject (hFont, sizeof (LOGFONT), (LPSTR) &lf) ;

      lf.lfHeight *= 2 ;
      lf.lfWidth  *= 2 ;
      lf.lfPitchAndFamily = lfSet[i].lfPitchAndFamily ;
      strcpy (lf.lfFaceName, lfSet[i].lfFaceName) ;

      hdc = CreateIC ("DISPLAY", NULL, NULL, NULL) ;
      hdcMem = CreateCompatibleDC (hdc) ;
      SelectObject (hdcMem, CreateFontIndirect (&lf)) ;
      dwSize = GetTextExtent (hdcMem, lfSet[i].szMenuText,
                              strlen (lfSet[i].szMenuText)) ;

      hBitmap = CreateBitmap (LOWORD (dwSize)-1, HIWORD (dwSize), 1, 1, NULL)
      SelectObject (hdcMem, hBitmap) ;


      TextOut (hdcMem, 0, 0, lfSet[i].szMenuText,
                             strlen (lfSet[i].szMenuText)) ;

      DeleteObject (SelectObject (hdcMem, hFont)) ;
      DeleteDC (hdcMem) ;
      DeleteDC (hdc) ;

      return hBitmap ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      HMENU  hMenu ;
      static short nCurrentFont = IDM_COUR ;

      switch (message)
           {
           case WM_CREATE:
                CheckMenuItem (GetMenu (hwnd), nCurrentFont, MF_CHECKED) ;
                return 0 ;

           case WM_SYSCOMMAND:
                switch (wParam)
                     {
                     case IDM_HELP:
                          MessageBox (hwnd, "Help not yet implemented.",
                                    szAppName, MB_OK | MB_ICONEXCLAMATION) ;
                          return 0 ;
                     }
                break ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_NEW:
                     case IDM_OPEN:
                     case IDM_SAVE:
                     case IDM_SAVEAS:
                     case IDM_UNDO:
                     case IDM_CUT:
                     case IDM_COPY:
                     case IDM_PASTE:
                     case IDM_CLEAR:
                          MessageBeep (0) ;
                          return 0 ;

                     case IDM_COUR:
                     case IDM_HELV:
                     case IDM_TMSRMN:
                          hMenu = GetMenu (hwnd) ;
                          CheckMenuItem (hMenu, nCurrentFont, MF_UNCHECKED) ;
                          nCurrentFont = wParam ;
                          CheckMenuItem (hMenu, nCurrentFont, MF_CHECKED) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 HEAD.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP06\HEAD.C

 /*---------------------------------------------
    HEAD.C -- Displays beginning (head) of file
              (c) Charles Petzold, 1990
   ---------------------------------------------*/

 #include <windows.h>
 #include <io.h>
 #include <string.h>
 #include <direct.h>

 #define  MAXPATH     100
 #define  MAXREAD    2048

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL ListProc (HWND, WORD, WORD, LONG) ;

 char    sReadBuffer [MAXREAD] ;
 FARPROC lpfnOldList ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "Head" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = COLOR_WINDOW + 1 ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "File Head",
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL     bValidFile ;
      static char     szFile [16] ;
      static HWND     hwndList, hwndText ;
      static OFSTRUCT ofs ;
      static RECT     rect ;
      char            szBuffer [MAXPATH + 1] ;
      HDC             hdc ;
      int             iHandle, i, iCount ;
      PAINTSTRUCT     ps ;
      TEXTMETRIC      tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                GetTextMetrics (hdc, &tm) ;
                ReleaseDC (hwnd, hdc) ;

                rect.left = 20 * tm.tmAveCharWidth ;
                rect.top  =  3 * tm.tmHeight ;

                hwndList = CreateWindow ("listbox", NULL,
                               WS_CHILDWINDOW | WS_VISIBLE | LBS_STANDARD,
                               tm.tmAveCharWidth, tm.tmHeight * 3,
                               tm.tmAveCharWidth * 13 +
                                    GetSystemMetrics (SM_CXVSCROLL),
                               tm.tmHeight * 10,
                               hwnd, 1,
                               GetWindowWord (hwnd, GWW_HINSTANCE), NULL) ;

                hwndText = CreateWindow ("static", getcwd (szBuffer, MAXPATH),
                               WS_CHILDWINDOW | WS_VISIBLE | SS_LEFT,
                               tm.tmAveCharWidth,           tm.tmHeight,
                               tm.tmAveCharWidth * MAXPATH, tm.tmHeight,
                               hwnd, 2,
                               GetWindowWord (hwnd, GWW_HINSTANCE), NULL) ;

                lpfnOldList = (FARPROC) GetWindowLong (hwndList, GWL_WNDPROC)

                SetWindowLong (hwndList, GWL_WNDPROC,
                          (LONG) MakeProcInstance ((FARPROC) ListProc,
                                    GetWindowWord (hwnd, GWW_HINSTANCE))) ;

                SendMessage (hwndList, LB_DIR, 0x37, (LONG) (LPSTR) "*.*") ;
                return 0 ;

           case WM_SIZE:
                rect.right  = LOWORD (lParam) ;
                rect.bottom = HIWORD (lParam) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndList) ;
                return 0 ;

           case WM_COMMAND:
                if (wParam == 1 && HIWORD (lParam) == LBN_DBLCLK)
                     {
                     if (LB_ERR == (i = (WORD) SendMessage (hwndList,
                                                   LB_GETCURSEL, 0, 0L)))
                          break ;

                     SendMessage (hwndList, LB_GETTEXT, i,
                                         (LONG) (char far *) szBuffer) ;

                     if (-1 != OpenFile (szBuffer, &ofs, OF_EXIST | OF_READ))
                          {
                          bValidFile = TRUE ;
                          strcpy (szFile, szBuffer) ;
                          getcwd (szBuffer, MAXPATH) ;
                          if (szBuffer [strlen (szBuffer) - 1] != '\\')
                               strcat (szBuffer, "\\") ;
                          SetWindowText (hwndText, strcat (szBuffer, szFile))
                          }
                     else
                          {
                          bValidFile = FALSE ;
                          szBuffer [strlen (szBuffer) - 1] = '\0' ;
                          chdir (szBuffer + 1) ;
                          getcwd (szBuffer, MAXPATH) ;
                          SetWindowText (hwndText, szBuffer) ;
                          SendMessage (hwndList, LB_RESETCONTENT, 0, 0L) ;
                          SendMessage (hwndList, LB_DIR, 0x37,
                                       (LONG) (LPSTR) "*.*") ;
                          }
                     InvalidateRect (hwnd, NULL, TRUE) ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                SetTextColor (hdc, GetSysColor (COLOR_WINDOWTEXT)) ;
                SetBkColor   (hdc, GetSysColor (COLOR_WINDOW)) ;

                if (bValidFile && -1 != (iHandle =
                          OpenFile (szFile, &ofs, OF_REOPEN | OF_READ)))
                     {
                     i = read (iHandle, sReadBuffer, MAXREAD) ;
                     close (iHandle) ;
                     DrawText (hdc, sReadBuffer, i, &rect, DT_WORDBREAK |
                                    DT_EXPANDTABS | DT_NOCLIP | DT_NOPREFIX) ;
                     }
                else
                     bValidFile = FALSE ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL ListProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      if (message == WM_KEYDOWN && wParam == VK_RETURN)

           SendMessage (GetParent (hwnd), WM_COMMAND, 1,
                          MAKELONG (hwnd, LBN_DBLCLK)) ;

      return CallWindowProc (lpfnOldList, hwnd, message, wParam, lParam) ;
      }


 HELLOWIN.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP01\HELLOWIN.C

 /*--------------------------------------------------------
    HELLOWIN.C -- Displays "Hello, Windows" in client area
                  (c) Charles Petzold, 1990
   --------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdParam, int nCmdShow)
      {
      static char szAppName[] = "HelloWin" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
     }

      hwnd = CreateWindow (szAppName,         // window class name
         "The Hello Program",     // window caption
                     WS_OVERLAPPEDWINDOW,     // window style
                     CW_USEDEFAULT,           // initial x position
                     CW_USEDEFAULT,           // initial y position
                     CW_USEDEFAULT,           // initial x size
                     CW_USEDEFAULT,           // initial y size
                     NULL,                    // parent window handle
                     NULL,                    // window menu handle
                     hInstance,               // program instance handle
         NULL) ;         // creation parameters

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      HDC         hdc ;
      PAINTSTRUCT ps ;
      RECT   rect ;

      switch (message)
           {
           case WM_PAINT:
          hdc = BeginPaint (hwnd, &ps) ;

                GetClientRect (hwnd, &rect) ;

          DrawText (hdc, "Hello, Windows!", -1, &rect,
        DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;

          EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }

      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 HEXCALC.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\HEXCALC.C

 /*----------------------------------------
    HEXCALC.C -- Hexadecimal Calculator
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "HexCalc" ;
      HWND        hwnd ;
      MSG         msg;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style          = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc    = WndProc ;
           wndclass.cbClsExtra     = 0 ;
           wndclass.cbWndExtra     = DLGWINDOWEXTRA ;
           wndclass.hInstance      = hInstance ;
           wndclass.hIcon          = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground  = COLOR_WINDOW + 1 ;
           wndclass.lpszMenuName   = NULL ;
           wndclass.lpszClassName  = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateDialog (hInstance, szAppName, 0, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void ShowNumber (HWND hwnd, DWORD dwNumber)
      {
      char szBuffer [20] ;

      SetDlgItemText (hwnd, VK_ESCAPE, strupr (ltoa (dwNumber, szBuffer, 16)))
      }

 DWORD CalcIt (DWORD dwFirstNum, short nOperation, DWORD dwNum)
      {
      switch (nOperation)
           {
           case '=' : return dwNum ;
           case '+' : return dwFirstNum +  dwNum ;
           case '-' : return dwFirstNum -  dwNum ;
           case '*' : return dwFirstNum *  dwNum ;
           case '&' : return dwFirstNum &  dwNum ;
           case '|' : return dwFirstNum |  dwNum ;
           case '^' : return dwFirstNum ^  dwNum ;
           case '<' : return dwFirstNum << dwNum ;
           case '>' : return dwFirstNum >> dwNum ;
           case '/' : return dwNum ? dwFirstNum / dwNum : ULONG_MAX ;
           case '%' : return dwNum ? dwFirstNum % dwNum : ULONG_MAX ;
           default  : return 0L ;
           }
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL  bNewNumber = TRUE ;
      static DWORD dwNumber, dwFirstNum ;
      static short nOperation = '=' ;
      HWND         hButton ;

      switch (message)
           {
           case WM_KEYDOWN:                   // left arrow --> backspace
                if (wParam != VK_LEFT)
                     break ;
                wParam = VK_BACK ;
                                              // fall through
           case WM_CHAR:
                if ((wParam = toupper (wParam)) == VK_RETURN)
                     wParam = '=' ;

                if (hButton = GetDlgItem (hwnd, wParam))
                     {
                     SendMessage (hButton, BM_SETSTATE, 1, 0L) ;
                     SendMessage (hButton, BM_SETSTATE, 0, 0L) ;
                     }
                else
                     {
                     MessageBeep (0) ;
                     break ;
                     }
                                              // fall through
           case WM_COMMAND:
                SetFocus (hwnd) ;

                if (wParam == VK_BACK)                  // backspace
                     ShowNumber (hwnd, dwNumber /= 16) ;

                else if (wParam == VK_ESCAPE)           // escape
                     ShowNumber (hwnd, dwNumber = 0L) ;

                else if (isxdigit (wParam))             // hex digit
                     {
                     if (bNewNumber)
                          {
                          dwFirstNum = dwNumber ;
                          dwNumber = 0L ;
                          }
                     bNewNumber = FALSE ;

                     if (dwNumber <= ULONG_MAX >> 4)
                          ShowNumber (hwnd, dwNumber = 16 * dwNumber + wParam
                               (isdigit (wParam) ? '0' : 'A' - 10)) ;
                     else
                          MessageBeep (0) ;
                     }
                else                                    // operation
                     {
                     if (!bNewNumber)
                          ShowNumber (hwnd, dwNumber =
                               CalcIt (dwFirstNum, nOperation, dwNumber)) ;
                     bNewNumber = TRUE ;
                     nOperation = wParam ;
                     }
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 JUSTIFY.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP14\JUSTIFY.C

 /*----------------------------------------
    JUSTIFY.C -- Justified Type Program
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "justify.h"

 typedef struct
      {
      short nNumFaces ;
      char  szFaceNames [MAX_FACES] [LF_FACESIZE] ;
      }
      ENUMFACE ;

 typedef struct
      {
      short      nNumSizes ;
      short      xLogPixPerInch ;
      short      yLogPixPerInch ;
      LOGFONT    lf [MAX_SIZES] ;
      TEXTMETRIC tm [MAX_SIZES] ;
      }
      ENUMSIZE ;

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 int  FAR PASCAL EnumAllFaces (LPLOGFONT, LPTEXTMETRIC, short, ENUMFACE FAR *)
 int  FAR PASCAL EnumAllSizes (LPLOGFONT, LPTEXTMETRIC, short, ENUMSIZE FAR *)

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static   char szAppName[] = "Justify" ;
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }
      hwnd = CreateWindow (szAppName, "Justified Type",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 int FAR PASCAL EnumAllFaces (LPLOGFONT lplf, LPTEXTMETRIC lptm,
                              short nFontType, ENUMFACE FAR *lpef)
      {
      if (nFontType & RASTER_FONTTYPE)
           {
           lstrcpy (lpef->szFaceNames[lpef->nNumFaces], lplf->lfFaceName) ;
           if (++lpef->nNumFaces == MAX_FACES)
                return 0 ;
           }
      return 1 ;
      }

 int FAR PASCAL EnumAllSizes (LPLOGFONT lplf, LPTEXTMETRIC lptm,
                              short nFontType, ENUMSIZE FAR *lpes)
      {
      if (lpes->xLogPixPerInch == lptm->tmDigitizedAspectX &&
          lpes->yLogPixPerInch == lptm->tmDigitizedAspectY)
           {
           lpes->lf [lpes->nNumSizes] = *lplf ;
           lpes->tm [lpes->nNumSizes] = *lptm ;
           if (++lpes->nNumSizes == MAX_SIZES)
                return 0 ;
           }
      return 1 ;
      }

 short MakeSizeMenu (HWND hwnd, FARPROC lpfnEnumAllSizes,
                     ENUMSIZE *pes, char *szFaceName)
      {
      static LOGFONT lfBlank ;
      char           szBuffer[20] ;
      HDC            hdc ;
      HMENU          hPopup ;
      short          i ;

      hdc = GetDC (hwnd) ;
      hPopup = GetSubMenu (GetMenu (hwnd), SIZE_MENU) ;

      pes->nNumSizes = 0 ;
      EnumFonts (hdc, szFaceName, lpfnEnumAllSizes, (LPSTR) pes) ;
      ReleaseDC (hwnd, hdc) ;

      while (GetMenuItemCount (hPopup) > 0)
           DeleteMenu (hPopup, 0, MF_BYPOSITION) ;

      if (pes->nNumSizes)
           for (i = 0 ; i < pes->nNumSizes ; i++)
                {
                wsprintf (szBuffer, "%i  %2d / %2d", i + 1,
                     (pes->tm[i].tmHeight - pes->tm[i].tmInternalLeading + 10)
                                                                         / 20,
                     (pes->tm[i].tmHeight + 10) / 20) ;
                AppendMenu (hPopup, 0, IDM_ISIZE + i, szBuffer) ;
                }
      else           /* no fonts found that match aspect ratio of display */
           {
           pes->lf[0] = lfBlank ;
           strcpy (pes->lf[0].lfFaceName, szFaceName) ;
           AppendMenu (hPopup, 0, IDM_ISIZE, "Default") ;
           }

      CheckMenuItem (hPopup, IDM_ISIZE, MF_CHECKED) ;
      return 0 ;
      }

 void DrawRuler (HDC hdc, POINT ptClient)
      {
      static short nRuleSize [16] = { 360, 72, 144, 72, 216, 72, 144, 72,
                                      288, 72, 144, 72, 216, 72, 144, 72 } ;
      short        i, j ;

      MoveTo (hdc, 0,          -360) ;
      LineTo (hdc, ptClient.x, -360) ;
      MoveTo (hdc, -360,          0) ;
      LineTo (hdc, -360, ptClient.y) ;

      for (i = 0, j = 0 ; i <= ptClient.x ; i += 1440 / 16, j++)
           {
           MoveTo (hdc, i, -360) ;
           LineTo (hdc, i, -360 - nRuleSize [j % 16]) ;
           }
      for (i = 0, j = 0 ; i <= ptClient.y ; i += 1440 / 16, j++)
           {
           MoveTo (hdc, -360, i) ;
           LineTo (hdc, -360 - nRuleSize [j % 16], i) ;
           }
      }

 void Justify (HDC hdc, HANDLE hResource, POINT ptClient, short nCurAlign)
      {
      DWORD  dwExtent ;
      LPSTR  lpText, lpBegin, lpEnd ;
      short  i, xStart, yStart, nBreakCount ;

      lpText = LockResource (hResource) ;

      yStart = 0 ;
      do                            // for each text line
           {
           nBreakCount = 0 ;
           while (*lpText == ' ')   // skip over leading blanks
                lpText++ ;
           lpBegin = lpText ;

           do                       // until the line is known
                {
                lpEnd = lpText ;

                while (*lpText != '\0' && *lpText++ != ' ') ;
                if (*lpText == '\0')
                     break ;
                                    // for each space, calculate extents
                nBreakCount++ ;
                SetTextJustification (hdc, 0, 0) ;
                dwExtent = GetTextExtent (hdc, lpBegin, lpText - lpBegin - 1)
                }
           while (LOWORD (dwExtent) < ptClient.x) ;

           nBreakCount-- ;
           while (*(lpEnd - 1) == ' ')   // eliminate trailing blanks
                {
                lpEnd-- ;
                nBreakCount-- ;
                }

           if (*lpText == '\0' || nBreakCount <= 0)
                lpEnd = lpText ;

           SetTextJustification (hdc, 0, 0) ;
           dwExtent = GetTextExtent (hdc, lpBegin, lpEnd - lpBegin) ;

           if (nCurAlign == IDM_LEFT)         // use alignment for xStart
                xStart = 0 ;

           else if (nCurAlign == IDM_RIGHT)
                xStart = ptClient.x - LOWORD (dwExtent) ;

           else if (nCurAlign == IDM_CENTER)
                xStart = (ptClient.x - LOWORD (dwExtent)) / 2 ;

           else
                {
                if (*lpText != '\0' && nBreakCount > 0)
                     SetTextJustification (hdc, ptClient.x - LOWORD (dwExtent)
                                                   nBreakCount) ;
                xStart = 0 ;
                }

           TextOut (hdc, xStart, yStart, lpBegin, lpEnd - lpBegin) ;
           yStart += HIWORD (dwExtent) ;
           lpText = lpEnd ;
           }
      while (*lpText && yStart < ptClient.y) ;

      GlobalUnlock (hResource) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static ENUMFACE ef ;
      static ENUMSIZE es ;
      static FARPROC  lpfnEnumAllFaces, lpfnEnumAllSizes ;
      static HANDLE   hResource ;
      static POINT    ptClient ;
      static short    nCurSize, nCurFace, nCurAttr, nCurAlign = IDM_LEFT ;
      HANDLE          hInstance ;
      HDC             hdc ;
      HFONT           hFont ;
      HMENU           hMenu, hPopup ;
      PAINTSTRUCT     ps ;
      short           i ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                es.xLogPixPerInch = GetDeviceCaps (hdc, LOGPIXELSX) ;
                es.yLogPixPerInch = GetDeviceCaps (hdc, LOGPIXELSY) ;

                               // Set Map Mode

                SetMapMode (hdc, MM_ANISOTROPIC) ;
                SetWindowExt (hdc, 1440, 1440) ;
                SetViewportExt (hdc, es.xLogPixPerInch, es.yLogPixPerInch) ;
                SetWindowOrg (hdc, -720, -720) ;

                               // MakeProcInstance for 2 routines

                hInstance = ((LPCREATESTRUCT) lParam)-> hInstance ;
                lpfnEnumAllFaces = MakeProcInstance (EnumAllFaces, hInstance)
                lpfnEnumAllSizes = MakeProcInstance (EnumAllSizes, hInstance)

                               // Enumerate the Font Faces

                EnumFonts (hdc, NULL, lpfnEnumAllFaces, (LPSTR) &ef) ;
                ReleaseDC (hwnd, hdc) ;

                               // Initialize the Menus

                hMenu  = GetMenu (hwnd) ;
                hPopup = CreateMenu () ;

                for (i = 0 ; i < ef.nNumFaces ; i++)
                     AppendMenu (hPopup, 0, IDM_IFACE + i, ef.szFaceNames[i])

                ModifyMenu (hMenu, IDM_FACE, MF_POPUP, hPopup, "&FaceName") ;
                CheckMenuItem (hMenu, IDM_IFACE, MF_CHECKED) ;

                nCurSize = MakeSizeMenu (hwnd, lpfnEnumAllSizes, &es,
                                    ef.szFaceNames [nCurFace]) ;

                               // Load the Text Resource

                hResource = LoadResource (hInstance,
                            FindResource (hInstance, "Ismael", "TEXT")) ;
                return 0 ;

           case WM_SIZE:
                hdc = GetDC (hwnd) ;
                ptClient = MAKEPOINT (lParam) ;
                DPtoLP (hdc, &ptClient, 1) ;
                ptClient.x -= 360 ;
                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_COMMAND:
                hMenu = GetMenu (hwnd) ;

                if (wParam >= IDM_IFACE && wParam < IDM_IFACE + MAX_FACES)
                     {
                     CheckMenuItem (hMenu, nCurFace + IDM_IFACE, MF_UNCHECKED)
                     CheckMenuItem (hMenu, wParam, MF_CHECKED) ;
                     nCurFace = wParam - IDM_IFACE ;

                     nCurSize = MakeSizeMenu (hwnd, lpfnEnumAllSizes, &es,
                                         ef.szFaceNames [nCurFace]) ;
                     }

                else if (wParam >= IDM_ISIZE && wParam < IDM_ISIZE + MAX_SIZES
                     {
                     CheckMenuItem (hMenu, nCurSize + IDM_ISIZE, MF_UNCHECKED)
                     CheckMenuItem (hMenu, wParam, MF_CHECKED) ;
                     nCurSize = wParam - IDM_ISIZE ;
                     }

                else switch (wParam)
                     {
                     case IDM_BOLD:
                     case IDM_ITALIC:
                     case IDM_STRIKE:
                     case IDM_UNDER:
                          CheckMenuItem (hMenu, wParam, MF_CHECKED &
                               GetMenuState (hMenu, wParam, MF_BYCOMMAND) ?
                                    MF_UNCHECKED : MF_CHECKED) ;
                          nCurAttr ^= wParam ;
                          break ;

                     case IDM_NORM:
                          nCurAttr = 0 ;
                          CheckMenuItem (hMenu, IDM_BOLD,   MF_UNCHECKED) ;
                          CheckMenuItem (hMenu, IDM_ITALIC, MF_UNCHECKED) ;
                          CheckMenuItem (hMenu, IDM_STRIKE, MF_UNCHECKED) ;
                          CheckMenuItem (hMenu, IDM_UNDER,  MF_UNCHECKED) ;
                          break ;

                     case IDM_LEFT:
                     case IDM_RIGHT:
                     case IDM_CENTER:
                     case IDM_JUST:
                          CheckMenuItem (hMenu, nCurAlign, MF_UNCHECKED) ;
                          nCurAlign = wParam ;
                          CheckMenuItem (hMenu, nCurAlign, MF_CHECKED) ;
                          break ;
                     }
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                es.lf[nCurSize].lfWeight    = nCurAttr & IDM_BOLD ? 700 : 400
                es.lf[nCurSize].lfItalic    = (BYTE) (nCurAttr & IDM_ITALIC) ;
                es.lf[nCurSize].lfUnderline = (BYTE) (nCurAttr & IDM_UNDER) ;
                es.lf[nCurSize].lfStrikeOut = (BYTE) (nCurAttr & IDM_STRIKE) ;

                hFont = CreateFontIndirect (&es.lf[nCurSize]) ;
                hFont = SelectObject (hdc, hFont) ;

                DrawRuler (hdc, ptClient) ;
                Justify (hdc, hResource, ptClient, nCurAlign) ;

                DeleteObject (SelectObject (hdc, hFont)) ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                FreeResource (hResource) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 KEYLOOK.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP03\KEYLOOK.C

 /*-------------------------------------------------------
    KEYLOOK.C -- Displays Keyboard and Character Messages
                 (c) Charles Petzold, 1990
   -------------------------------------------------------*/

 #include <windows.h>
 #include <stdio.h>

 long  FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 RECT  rect ;
 short cxChar, cyChar ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "KeyLook" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Keyboard Message Looker",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void ShowKey (HWND hwnd, int iType, char *szMessage, WORD wParam, LONG lParam
      {
      static char *szFormat[2] = { "%-14s %3d    %c %6u %4d %3s %3s %4s %4s",
                                   "%-14s    %3d %c %6u %4d %3s %3s %4s %4s" }
      char        szBuffer[80] ;
      HDC         hdc ;

      ScrollWindow (hwnd, 0, -cyChar, &rect, &rect) ;
      hdc = GetDC (hwnd) ;

      SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

      TextOut (hdc, cxChar, rect.bottom - cyChar, szBuffer,
               wsprintf (szBuffer, szFormat [iType],
                         (LPSTR) szMessage, wParam,
                         (BYTE) (iType ? wParam : ' '),
                         LOWORD (lParam),
                         HIWORD (lParam) & 0xFF,
                         (LPSTR) (0x01000000 & lParam ? "Yes"  : "No"),
                         (LPSTR) (0x20000000 & lParam ? "Yes"  : "No"),
                         (LPSTR) (0x40000000 & lParam ? "Down" : "Up"),
                         (LPSTR) (0x80000000 & lParam ? "Up"   : "Down"))) ;

      ReleaseDC (hwnd, hdc) ;
      ValidateRect (hwnd, NULL) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char szTop[] =
                     "Message        Key Char Repeat Scan Ext ALT Prev Tran";
      static char szUnd[]=
                     "_______        ___ ____ ______ ____ ___ ___ ____ ____";
      HDC         hdc ;
      PAINTSTRUCT ps ;
      TEXTMETRIC  tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight ;

                ReleaseDC (hwnd, hdc) ;

                rect.top = 3 * cyChar / 2 ;
                return 0 ;

           case WM_SIZE:
                rect.right  = LOWORD (lParam) ;
                rect.bottom = HIWORD (lParam) ;
                UpdateWindow (hwnd) ;
                return 0 ;

           case WM_PAINT:
                InvalidateRect (hwnd, NULL, TRUE) ;
                hdc = BeginPaint (hwnd, &ps) ;

                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                SetBkMode (hdc, TRANSPARENT) ;
                TextOut (hdc, cxChar, cyChar / 2, szTop, (sizeof szTop) - 1) ;
                TextOut (hdc, cxChar, cyChar / 2, szUnd, (sizeof szUnd) - 1) ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_KEYDOWN:
                ShowKey (hwnd, 0, "WM_KEYDOWN", wParam, lParam) ;
                return 0 ;

           case WM_KEYUP:
                ShowKey (hwnd, 0, "WM_KEYUP", wParam, lParam) ;
                return 0 ;

           case WM_CHAR:
                ShowKey (hwnd, 1, "WM_CHAR", wParam, lParam) ;
                return 0 ;

           case WM_DEADCHAR:
                ShowKey (hwnd, 1, "WM_DEADCHAR", wParam, lParam) ;
                return 0 ;

           case WM_SYSKEYDOWN:
                ShowKey (hwnd, 0, "WM_SYSKEYDOWN", wParam, lParam) ;
                break ;        // ie, call DefWindowProc

           case WM_SYSKEYUP:
                ShowKey (hwnd, 0, "WM_SYSKEYUP", wParam, lParam) ;
                break ;        // ie, call DefWindowProc

           case WM_SYSCHAR:
                ShowKey (hwnd, 1, "WM_SYSCHAR", wParam, lParam) ;
                break ;        // ie, call DefWindowProc

           case WM_SYSDEADCHAR:
                ShowKey (hwnd, 1, "WM_SYSDEADCHAR", wParam, lParam) ;
                break ;        // ie, call DefWindowProc

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 LINEDDA.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP12\LINEDDA.C

 /*----------------------------------------
    LINEDDA.C -- LineDDA Demonstration
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 void FAR PASCAL LineProc (short, short, LPSTR) ;

 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "LineDDA" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, "LineDDA Demonstration",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpfnLineProc ;
      static short   cxClient, cyClient, xL, xR, yT, yB ;
      HDC            hdc ;
      PAINTSTRUCT    ps ;

      switch (message)
           {
           case WM_CREATE:
                lpfnLineProc = MakeProcInstance (LineProc, hInst) ;
                return 0 ;

           case WM_SIZE:
                xR = 3 * (xL = (cxClient = LOWORD (lParam)) / 4) ;
                yB = 3 * (yT = (cyClient = HIWORD (lParam)) / 4) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                LineDDA (xL, yT, xR, yT, lpfnLineProc, (LPSTR) &hdc) ;
                LineDDA (xR, yT, xR, yB, lpfnLineProc, (LPSTR) &hdc) ;
                LineDDA (xR, yB, xL, yB, lpfnLineProc, (LPSTR) &hdc) ;
                LineDDA (xL, yB, xL, yT, lpfnLineProc, (LPSTR) &hdc) ;

                LineDDA (0,       0,       xL, yT, lpfnLineProc, (LPSTR) &hdc)
                LineDDA (cxClient, 0,       xR, yT, lpfnLineProc, (LPSTR) &hdc
                LineDDA (cxClient, cyClient, xR, yB, lpfnLineProc, (LPSTR) &hd
                LineDDA (0,       cyClient, xL, yB, lpfnLineProc, (LPSTR) &hdc

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 void FAR PASCAL LineProc (short x, short y, LPSTR lpData)
      {
      static short nCounter = 0 ;

      if (nCounter == 2)
           Ellipse (* (HDC far *) lpData, x - 2, y - 2, x + 3, y + 3) ;

      nCounter = (nCounter + 1) % 4 ;
      }


 MDIDEMO.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP18\MDIDEMO.C

 /*--------------------------------------------------------
    MDIDEMO.C -- Multiple Document Interface Demonstration
                 (c) Charles Petzold, 1990
   --------------------------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>
 #include "mdidemo.h"

 long FAR PASCAL FrameWndProc  (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL CloseEnumProc (HWND, LONG) ;
 long FAR PASCAL HelloWndProc  (HWND, WORD, WORD, LONG) ;
 long FAR PASCAL RectWndProc   (HWND, WORD, WORD, LONG) ;

           // structure for storing data unique to each Hello child window

 typedef struct
      {
      short    nColor ;
      COLORREF clrText ;
      }
      HELLODATA ;

 typedef HELLODATA NEAR *NPHELLODATA ;

           // structure for storing data unique to each Rect child window

 typedef struct
      {
      short cxClient ;
      short cyClient ;
      }
      RECTDATA ;

 typedef RECTDATA NEAR *NPRECTDATA ;

           // global variables

 char   szFrameClass [] = "MdiFrame" ;
 char   szHelloClass [] = "MdiHelloChild" ;
 char   szRectClass  [] = "MdiRectChild" ;
 HANDLE hInst ;
 HMENU  hMenuInit, hMenuHello, hMenuRect ;
 HMENU  hMenuInitWindow, hMenuHelloWindow, hMenuRectWindow ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HANDLE   hAccel ;
      HWND     hwndFrame, hwndClient ;
      MSG      msg ;
      WNDCLASS wndclass ;

      hInst = hInstance ;

      if (!hPrevInstance)
           {
                     // Register the frame window class

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = FrameWndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = COLOR_APPWORKSPACE + 1 ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szFrameClass ;

           RegisterClass (&wndclass) ;

                     // Register the Hello child window class

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = HelloWndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = sizeof (LOCALHANDLE) ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szHelloClass ;

           RegisterClass (&wndclass) ;

                     // Register the Rect child window class

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = RectWndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = sizeof (LOCALHANDLE) ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szRectClass ;

           RegisterClass (&wndclass) ;
           }
                // Obtain handles to three possible menus & submenus

      hMenuInit  = LoadMenu (hInst, "MdiMenuInit") ;
      hMenuHello = LoadMenu (hInst, "MdiMenuHello") ;
      hMenuRect  = LoadMenu (hInst, "MdiMenuRect") ;

      hMenuInitWindow  = GetSubMenu (hMenuInit,   INIT_MENU_POS) ;
      hMenuHelloWindow = GetSubMenu (hMenuHello, HELLO_MENU_POS) ;
      hMenuRectWindow  = GetSubMenu (hMenuRect,   RECT_MENU_POS) ;

                // Load accelerator table

      hAccel = LoadAccelerators (hInst, "MdiAccel") ;

                // Create the frame window

      hwndFrame = CreateWindow (szFrameClass, "MDI Demonstration",
                                WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                                CW_USEDEFAULT, CW_USEDEFAULT,
                                CW_USEDEFAULT, CW_USEDEFAULT,
                                NULL, hMenuInit, hInstance, NULL) ;

      hwndClient = GetWindow (hwndFrame, GW_CHILD) ;

      ShowWindow (hwndFrame, nCmdShow) ;
      UpdateWindow (hwndFrame) ;

                // Enter the modified message loop

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (!TranslateMDISysAccel (hwndClient, &msg) &&
               !TranslateAccelerator (hwndFrame, hAccel, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return msg.wParam ;
      }

 long FAR PASCAL FrameWndProc (HWND hwnd, WORD message, WORD wParam, LONG lPar
      {
      static HWND        hwndClient ;
      CLIENTCREATESTRUCT clientcreate ;
      FARPROC            lpfnEnum ;
      HWND               hwndChild, hwndNext ;
      MDICREATESTRUCT    mdicreate ;

      switch (message)
           {
           case WM_CREATE:          // Create the client window

                clientcreate.hWindowMenu  = hMenuInitWindow ;
                clientcreate.idFirstChild = IDM_FIRSTCHILD ;

                hwndClient = CreateWindow ("MDICLIENT", NULL,
                               WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
                               0, 0, 0, 0, hwnd, 1, hInst,
                               (LPSTR) &clientcreate) ;
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_NEWHELLO:       // Create a Hello child window

                          mdicreate.szClass = szHelloClass ;
                          mdicreate.szTitle = "Hello" ;
                          mdicreate.hOwner  = hInst ;
                          mdicreate.x       = CW_USEDEFAULT ;
                          mdicreate.y       = CW_USEDEFAULT ;
                          mdicreate.cx      = CW_USEDEFAULT ;
                          mdicreate.cy      = CW_USEDEFAULT ;
                          mdicreate.style   = 0 ;
                          mdicreate.lParam  = NULL ;

                          hwndChild = SendMessage (hwndClient, WM_MDICREATE, 0
                                         (LONG) (LPMDICREATESTRUCT) &mdicreate
                          return 0 ;

                     case IDM_NEWRECT:        // Create a Rect child window

                          mdicreate.szClass = szRectClass ;
                          mdicreate.szTitle = "Rectangles" ;
                          mdicreate.hOwner  = hInst ;
                          mdicreate.x       = CW_USEDEFAULT ;
                          mdicreate.y       = CW_USEDEFAULT ;
                          mdicreate.cx      = CW_USEDEFAULT ;
                          mdicreate.cy      = CW_USEDEFAULT ;
                          mdicreate.style   = 0 ;
                          mdicreate.lParam  = NULL ;

                          hwndChild = SendMessage (hwndClient,  WM_MDICREATE,
                                         (LONG) (LPMDICREATESTRUCT) &mdicreate
                          return 0 ;

                     case IDM_CLOSE:          // Close the active window

                          hwndChild = LOWORD (SendMessage (hwndClient,
                                                   WM_MDIGETACTIVE, 0, 0L)) ;

                          if (SendMessage (hwndChild, WM_QUERYENDSESSION, 0, 0
                               SendMessage (hwndClient, WM_MDIDESTROY,
                                            hwndChild, 0L) ;
                          return 0 ;

                     case IDM_EXIT:           // Exit the program

                          SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                          return 0 ;

                                    // Messages for arranging windows
                     case IDM_TILE:
                          SendMessage (hwndClient, WM_MDITILE, 0, 0L) ;
                          return 0 ;

                     case IDM_CASCADE:
                          SendMessage (hwndClient, WM_MDICASCADE, 0, 0L) ;
                          return 0 ;

                     case IDM_ARRANGE:
                          SendMessage (hwndClient, WM_MDIICONARRANGE, 0, 0L) ;
                          return 0 ;

                     case IDM_CLOSEALL:       // Attempt to close all children

                          lpfnEnum = MakeProcInstance (CloseEnumProc, hInst) ;
                          EnumChildWindows (hwndClient, lpfnEnum, 0L) ;
                          FreeProcInstance (lpfnEnum) ;
                          return 0 ;

                     default:            // Pass to active child

                          hwndChild = LOWORD (SendMessage (hwndClient,
                                                 WM_MDIGETACTIVE, 0, 0L)) ;

                         if (IsWindow (hwndChild))
                              SendMessage (hwndChild, WM_COMMAND,
                                           wParam, lParam) ;

                         break ;        // and then to DefFrameProc
                     }
                break ;

           case WM_QUERYENDSESSION:
           case WM_CLOSE:                     // Attempt to close all children

                SendMessage (hwnd, WM_COMMAND, IDM_CLOSEALL, 0L) ;

                if (NULL != GetWindow (hwndClient, GW_CHILD))
                     return 0 ;

                break ;   // ie, call DefFrameProc ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
                // Pass unprocessed messages to DefFrameProc (not DefWindowPro

      return DefFrameProc (hwnd, hwndClient, message, wParam, lParam) ;
      }

 BOOL FAR PASCAL CloseEnumProc (HWND hwnd, LONG lParam)
      {
      if (GetWindow (hwnd, GW_OWNER))         // check for icon title
           return 1 ;

      SendMessage (GetParent (hwnd), WM_MDIRESTORE, hwnd, 0L) ;

      if (!SendMessage (hwnd, WM_QUERYENDSESSION, 0, 0L))
           return 1 ;

      SendMessage (GetParent (hwnd), WM_MDIDESTROY, hwnd, 0L) ;
           return 1 ;
      }

 long FAR PASCAL HelloWndProc (HWND hwnd, WORD message, WORD wParam, LONG lPar
      {
      static COLORREF clrTextArray [] = { RGB (0,   0, 0), RGB (255, 0,   0),
                                          RGB (0, 255, 0), RGB (  0, 0, 255),
                                          RGB (255, 255, 255) } ;
      static HWND     hwndClient, hwndFrame ;
      HDC             hdc ;
      HMENU           hMenu ;
      LOCALHANDLE     hHelloData ;
      NPHELLODATA     npHelloData ;
      PAINTSTRUCT     ps ;
      RECT            rect ;

      switch (message)
           {
           case WM_CREATE:
                          // Allocate memory for window private data

                hHelloData = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT,
                                         sizeof (HELLODATA)) ;

                npHelloData = (NPHELLODATA) LocalLock (hHelloData) ;
                npHelloData->nColor  = IDM_BLACK ;
                npHelloData->clrText = RGB (0, 0, 0) ;
                LocalUnlock (hHelloData) ;
                SetWindowWord (hwnd, 0, hHelloData) ;

                          // Save some window handles

                hwndClient = GetParent (hwnd) ;
                hwndFrame  = GetParent (hwndClient) ;
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_BLACK:
                     case IDM_RED:
                     case IDM_GREEN:
                     case IDM_BLUE:
                     case IDM_WHITE:
                                    // Change the text color

                          hHelloData  = GetWindowWord (hwnd, 0) ;
                          npHelloData = (NPHELLODATA) LocalLock (hHelloData) ;

                          hMenu = GetMenu (hwndFrame) ;

                          CheckMenuItem (hMenu, npHelloData->nColor,
                                                MF_UNCHECKED) ;
                          npHelloData->nColor = wParam ;
                          CheckMenuItem (hMenu, npHelloData->nColor,
                                                MF_CHECKED) ;

                          npHelloData->clrText =
                                clrTextArray [wParam - IDM_BLACK] ;

                          LocalUnlock (hHelloData) ;
                          InvalidateRect (hwnd, NULL, FALSE) ;
                     }
                return 0 ;

           case WM_PAINT:
                          // Paint the window

          hdc = BeginPaint (hwnd, &ps) ;

                hHelloData  = GetWindowWord (hwnd, 0) ;
                npHelloData = (NPHELLODATA) LocalLock (hHelloData) ;
                SetTextColor (hdc, npHelloData->clrText) ;
                LocalUnlock (hHelloData) ;

                GetClientRect (hwnd, &rect) ;

                DrawText (hdc, "Hello, World!", -1, &rect,
                          DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_MDIACTIVATE:

                          // Set the Hello menu if gaining focus

                if (wParam == TRUE)
                     SendMessage (hwndClient, WM_MDISETMENU, 0,
                                  MAKELONG (hMenuHello, hMenuHelloWindow)) ;

                          // check or uncheck menu item

                hHelloData  = GetWindowWord (hwnd, 0) ;
                npHelloData = (NPHELLODATA) LocalLock (hHelloData) ;
                CheckMenuItem (hMenuHello, npHelloData->nColor,
                               wParam ? MF_CHECKED : MF_UNCHECKED) ;
                LocalUnlock (hHelloData) ;

                          // Set the Init menu if losing focus

                if (wParam == FALSE)
                     SendMessage (hwndClient, WM_MDISETMENU, 0,
                                  MAKELONG (hMenuInit, hMenuInitWindow)) ;

                DrawMenuBar (hwndFrame) ;
                return 0 ;

           case WM_QUERYENDSESSION:
           case WM_CLOSE:
                if (IDOK != MessageBox (hwnd, "OK to close window?", "Hello",
                                        MB_ICONQUESTION | MB_OKCANCEL))
                     return 0 ;

                break ;   // ie, call DefMDIChildProc

           case WM_DESTROY:
                hHelloData = GetWindowWord (hwnd, 0) ;
                LocalFree (hHelloData) ;
                return 0 ;
           }
                // Pass unprocessed message to DefMDIChildProc

      return DefMDIChildProc (hwnd, message, wParam, lParam) ;
      }

 long FAR PASCAL RectWndProc (HWND hwnd, WORD message, WORD wParam, LONG lPara
      {
      static HWND hwndClient, hwndFrame ;
      HPEN        hBrush ;
      HDC         hdc ;
      LOCALHANDLE hRectData ;
      NPRECTDATA  npRectData ;
      PAINTSTRUCT ps ;
      short       xLeft, xRight, yTop, yBottom, nRed, nGreen, nBlue ;

      switch (message)
           {
           case WM_CREATE:
                          // Allocate memory for window private data

                hRectData = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT,
                                        sizeof (RECTDATA)) ;

                SetWindowWord (hwnd, 0, hRectData) ;

                          // Start the timer going

                SetTimer (hwnd, 1, 250, NULL) ;

                          // Save some window handles

                hwndClient = GetParent (hwnd) ;
                hwndFrame  = GetParent (hwndClient) ;
                return 0 ;

           case WM_SIZE:            // Save the window size

                hRectData  = GetWindowWord (hwnd, 0) ;
                npRectData = (NPRECTDATA) LocalLock (hRectData) ;

                npRectData->cxClient = LOWORD (lParam) ;
                npRectData->cyClient = HIWORD (lParam) ;

                LocalUnlock (hRectData) ;

                break ;        // WM_SIZE must be processed by DefMDIChildProc

           case WM_TIMER:           // Display a random rectangle

                hRectData  = GetWindowWord (hwnd, 0) ;
                npRectData = (NPRECTDATA) LocalLock (hRectData) ;

                xLeft   = rand () % npRectData->cxClient ;
                xRight  = rand () % npRectData->cxClient ;
                yTop    = rand () % npRectData->cyClient ;
                yBottom = rand () % npRectData->cyClient ;
                nRed    = rand () & 255 ;
                nGreen  = rand () & 255 ;
                nBlue   = rand () & 255 ;

                hdc = GetDC (hwnd) ;
                hBrush = CreateSolidBrush (RGB (nRed, nGreen, nBlue)) ;
                SelectObject (hdc, hBrush) ;

                Rectangle (hdc, min (xLeft, xRight), min (yTop, yBottom),
                                max (xLeft, xRight), max (yTop, yBottom)) ;

                ReleaseDC (hwnd, hdc) ;
                DeleteObject (hBrush) ;
                LocalUnlock (hRectData) ;
                return 0 ;

           case WM_PAINT:           // Clear the window

                InvalidateRect (hwnd, NULL, TRUE) ;
                hdc = BeginPaint (hwnd, &ps) ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_MDIACTIVATE:     // Set the appropriate menu
                if (wParam == TRUE)
                     SendMessage (hwndClient, WM_MDISETMENU, 0,
                                  MAKELONG (hMenuRect, hMenuRectWindow)) ;
                else
                     SendMessage (hwndClient, WM_MDISETMENU, 0,
                                  MAKELONG (hMenuInit, hMenuInitWindow)) ;

                DrawMenuBar (hwndFrame) ;
                return 0 ;

           case WM_DESTROY:
                hRectData = GetWindowWord (hwnd, 0) ;
                LocalFree (hRectData) ;
                KillTimer (hwnd, 1) ;
                return 0 ;
           }
                // Pass unprocessed message to DefMDIChildProc

      return DefMDIChildProc (hwnd, message, wParam, lParam) ;
      }


 MENUDEMO.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\MENUDEMO.C

 /*-----------------------------------------
    MENUDEMO.C -- Menu Demonstration
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #include "menudemo.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 char szAppName [] = "MenuDemo" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Menu Demonstration",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static int  wColorID [5] = { WHITE_BRUSH,  LTGRAY_BRUSH, GRAY_BRUSH,
                                   DKGRAY_BRUSH, BLACK_BRUSH } ;
      static WORD wSelection = IDM_WHITE ;
      HMENU       hMenu ;

      switch (message)
           {
           case WM_COMMAND:
                hMenu = GetMenu (hwnd) ;

                switch (wParam)
                     {
                     case IDM_NEW:
                     case IDM_OPEN:
                     case IDM_SAVE:
                     case IDM_SAVEAS:
                          MessageBeep (0) ;
                          return 0 ;

                     case IDM_EXIT:
                          SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                          return 0 ;

                     case IDM_UNDO:
                     case IDM_CUT:
                     case IDM_COPY:
                     case IDM_PASTE:
                     case IDM_CLEAR:
                          MessageBeep (0) ;
                          return 0 ;

                     case IDM_WHITE:          // Note: Logic below
                     case IDM_LTGRAY:         //   assumes that IDM_WHITE
                     case IDM_GRAY:           //   through IDM_BLACK are
                     case IDM_DKGRAY:         //   consecutive numbers in
                     case IDM_BLACK:          //   the order shown here.

                          CheckMenuItem (hMenu, wSelection, MF_UNCHECKED) ;
                          wSelection = wParam ;
                          CheckMenuItem (hMenu, wSelection, MF_CHECKED) ;

                          SetClassWord (hwnd, GCW_HBRBACKGROUND,
                               GetStockObject (wColorID [wParam - IDM_WHITE]))

                          InvalidateRect (hwnd, NULL, TRUE) ;
                          return 0 ;

                     case IDM_START:
                          if (SetTimer (hwnd, 1, 1000, NULL))
                               {
                               EnableMenuItem (hMenu, IDM_START, MF_GRAYED) ;
                               EnableMenuItem (hMenu, IDM_STOP,  MF_ENABLED) ;
                               }
                          return 0 ;

                     case IDM_STOP:
                          KillTimer (hwnd, 1) ;
                          EnableMenuItem (hMenu, IDM_START, MF_ENABLED) ;
                          EnableMenuItem (hMenu, IDM_STOP,  MF_GRAYED) ;
                          return 0 ;

                     case IDM_HELP:
                          MessageBox (hwnd, "Help not yet implemented.",
                                      szAppName, MB_ICONINFORMATION | MB_OK) ;
                          return 0 ;

                     case IDM_ABOUT:
                          MessageBox (hwnd, "Menu Demonstration Program.",
                                      szAppName, MB_ICONINFORMATION | MB_OK) ;
                          return 0 ;
                     }
                break ;

           case WM_TIMER:
                MessageBeep (0) ;
                return 0 ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 MFCREATE.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP13\MFCREATE.C

 /*-----------------------------------------
    MFCREATE.C -- Metafile Creation Program
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HBRUSH hBrush  = CreateSolidBrush (RGB (0, 0, 255)) ;
      HDC    hdcMeta = CreateMetaFile ("MYLOGO.WMF") ;

      Rectangle (hdcMeta, 0, 0, 100, 100) ;
      MoveTo (hdcMeta, 0, 0) ;
      LineTo (hdcMeta, 100, 100) ;
      MoveTo (hdcMeta, 0, 100) ;
      LineTo (hdcMeta, 100, 0) ;
      SelectObject (hdcMeta, hBrush) ;
      Ellipse (hdcMeta, 20, 20, 80, 80) ;

      DeleteMetaFile (CloseMetaFile (hdcMeta)) ;
      DeleteObject (hBrush) ;

      MessageBeep (0) ;

      return FALSE ;
      }


 MFRESORC.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP13\MFRESORC.C

 /*-----------------------------------------
    MFRESORC.C -- Metafile Resource Program
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "MFResorc" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Metafile Resource Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HANDLE hmf ;
      static short  cxClient, cyClient ;
      HANDLE        hInstance, hResource ;
      HDC           hdc ;
      PAINTSTRUCT   ps ;
      short         x, y ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = ((LPCREATESTRUCT) lParam) -> hInstance ;
                hResource = LoadResource (hInstance,
                            FindResource (hInstance, "MyLogo", "METAFILE")) ;

                LockResource (hResource) ;
                hmf = SetMetaFileBits (hResource) ;
                UnlockResource (hResource) ;
                return 0 ;

           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                SetMapMode (hdc, MM_ANISOTROPIC) ;
                SetWindowExt (hdc, 1000, 1000) ;
                SetViewportExt (hdc, cxClient, cyClient) ;

                for (x = 0 ; x < 10 ; x++)
                     for (y = 0 ; y < 10 ; y++)
                          {
                          SetWindowOrg (hdc, -100 * x, -100 * y) ;
                          PlayMetaFile (hdc, hmf) ;
                          }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                DeleteMetaFile (hmf) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 NOPOPUPS.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\NOPOPUPS.C

 /*-------------------------------------------------
    NOPOPUPS.C -- Demonstrates No-Popup Nested Menu
                  (c) Charles Petzold, 1990
   -------------------------------------------------*/

 #include <windows.h>
 #include "nopopups.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName [] = "NoPopUps" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "No-Popup Nested Menu Demonstration",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HMENU hMenuMain, hMenuEdit, hMenuFile ;
      HANDLE       hInstance ;

      switch (message)
           {
           case WM_CREATE:
                hInstance = GetWindowWord (hwnd, GWW_HINSTANCE) ;

                hMenuMain = LoadMenu (hInstance, "MenuMain") ;
                hMenuFile = LoadMenu (hInstance, "MenuFile") ;
                hMenuEdit = LoadMenu (hInstance, "MenuEdit") ;

                SetMenu (hwnd, hMenuMain) ;
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_MAIN:
                          SetMenu (hwnd, hMenuMain) ;
                          return 0 ;

                     case IDM_FILE:
                          SetMenu (hwnd, hMenuFile) ;
                          return 0 ;

                     case IDM_EDIT:
                          SetMenu (hwnd, hMenuEdit) ;
                          return 0 ;

                     case IDM_NEW:
                     case IDM_OPEN:
                     case IDM_SAVE:
                     case IDM_SAVEAS:
                     case IDM_UNDO:
                     case IDM_CUT:
                     case IDM_COPY:
                     case IDM_PASTE:
                     case IDM_CLEAR:
                          MessageBeep (0) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 PICKFONT.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP14\PICKFONT.C

 /*-----------------------------------------
    PICKFONT.C -- Font Picker Program
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #include "pickfont.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 BOOL FAR PASCAL DlgProc (HWND, WORD, WORD, LONG) ;

 char    szAppName [] = "PickFont" ;
 DWORD   dwAspectMatch = 0L ;
 HWND    hDlg ;
 LOGFONT lf ;
 short   nMapMode = IDD_TEXT ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Font Picker",
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (hDlg == 0 || !IsDialogMessage (hDlg, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage  (&msg) ;
                }
           }
      return msg.wParam ;
      }

 void MySetMapMode (HDC hdc)
      {
      if (nMapMode == IDD_LTWPS)
           {
           SetMapMode (hdc, MM_ANISOTROPIC) ;
           SetWindowExt (hdc, 1440, 1440) ;
           SetViewportExt (hdc, GetDeviceCaps (hdc, LOGPIXELSX),
                                GetDeviceCaps (hdc, LOGPIXELSY)) ;
           }
      else
           SetMapMode (hdc, MM_TEXT + nMapMode - IDD_TEXT) ;
      }

 void ShowMetrics (HWND hDlg)
      {
      static TEXTMETRIC tm ;
      static struct
           {
           short nDlgID ;
           short *pData ;
           }
           shorts [] =
           {
           TM_HEIGHT,     &tm.tmHeight,
           TM_ASCENT,     &tm.tmAscent,
           TM_DESCENT,    &tm.tmDescent,
           TM_INTLEAD,    &tm.tmInternalLeading,
           TM_EXTLEAD,    &tm.tmExternalLeading,
           TM_AVEWIDTH,   &tm.tmAveCharWidth,
           TM_MAXWIDTH,   &tm.tmMaxCharWidth,
           TM_WEIGHT,     &tm.tmWeight,
           TM_OVER,       &tm.tmOverhang,
           TM_DIGX,       &tm.tmDigitizedAspectX,
           TM_DIGY,       &tm.tmDigitizedAspectY
           } ;
      static char    *szFamily [] = { "Don't Care", "Roman",  "Swiss",
                                      "Modern",     "Script", "Decorative" } ;
      BOOL           bTrans ;
      char           szFaceName [LF_FACESIZE] ;
      HDC            hdc ;
      HFONT          hFont ;
      short          i ;

      lf.lfHeight    = GetDlgItemInt (hDlg, IDD_HEIGHT, &bTrans, TRUE) ;
      lf.lfWidth     = GetDlgItemInt (hDlg, IDD_WIDTH,  &bTrans, FALSE) ;
      lf.lfWeight    = GetDlgItemInt (hDlg, IDD_WEIGHT, &bTrans, FALSE) ;

      lf.lfItalic    = (BYTE) (IsDlgButtonChecked (hDlg, IDD_ITALIC) ? 1 : 0)
      lf.lfUnderline = (BYTE) (IsDlgButtonChecked (hDlg, IDD_UNDER)  ? 1 : 0)
      lf.lfStrikeOut = (BYTE) (IsDlgButtonChecked (hDlg, IDD_STRIKE) ? 1 : 0)

      GetDlgItemText (hDlg, IDD_FACE, lf.lfFaceName, LF_FACESIZE) ;

      dwAspectMatch = IsDlgButtonChecked (hDlg, IDD_ASPECT) ? 1L : 0L ;

      hdc = GetDC (hDlg) ;
      MySetMapMode (hdc) ;
      SetMapperFlags (hdc, dwAspectMatch) ;

      hFont = SelectObject (hdc, CreateFontIndirect (&lf)) ;
      GetTextMetrics (hdc, &tm) ;
      GetTextFace (hdc, sizeof szFaceName, szFaceName) ;

      DeleteObject (SelectObject (hdc, hFont)) ;
      ReleaseDC (hDlg, hdc) ;

      for (i = 0 ; i < sizeof shorts / sizeof shorts [0] ; i++)
           SetDlgItemInt (hDlg, shorts[i].nDlgID, *shorts[i].pData, TRUE) ;

      SetDlgItemText (hDlg, TM_PITCH, tm.tmPitchAndFamily & 1 ?
                                                       "VARIABLE":"FIXED") ;

      SetDlgItemText (hDlg, TM_FAMILY, szFamily [tm.tmPitchAndFamily >> 4]) ;
      SetDlgItemText (hDlg, TM_CHARSET, tm.tmCharSet ? "OEM" : "ANSI") ;
      SetDlgItemText (hDlg, TF_NAME, szFaceName) ;
      }

 BOOL FAR PASCAL DlgProc (HWND hDlg, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_INITDIALOG:
                CheckRadioButton (hDlg, IDD_TEXT,   IDD_LTWPS,  IDD_TEXT) ;
                CheckRadioButton (hDlg, IDD_ANSI,   IDD_OEM,    IDD_ANSI) ;
                CheckRadioButton (hDlg, IDD_QDRAFT, IDD_QPROOF, IDD_QDRAFT) ;
                CheckRadioButton (hDlg, IDD_PDEF,   IDD_PVAR,   IDD_PDEF) ;
                CheckRadioButton (hDlg, IDD_DONT,   IDD_DEC,    IDD_DONT) ;

                lf.lfEscapement    = 0 ;
                lf.lfOrientation   = 0 ;
                lf.lfOutPrecision  = OUT_DEFAULT_PRECIS ;
                lf.lfClipPrecision = CLIP_DEFAULT_PRECIS ;

                ShowMetrics (hDlg) ;
                                         /* fall through */
           case WM_SETFOCUS:
                SetFocus (GetDlgItem (hDlg, IDD_HEIGHT)) ;
                return FALSE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDD_TEXT:
                     case IDD_LOMET:
                     case IDD_HIMET:
                     case IDD_LOENG:
                     case IDD_HIENG:
                     case IDD_TWIPS:
                     case IDD_LTWPS:
                          CheckRadioButton (hDlg, IDD_TEXT, IDD_LTWPS, wParam)
                          nMapMode = wParam ;
                          break ;

                     case IDD_ASPECT:
                     case IDD_ITALIC:
                     case IDD_UNDER:
                     case IDD_STRIKE:
                          CheckDlgButton (hDlg, wParam,
                               IsDlgButtonChecked (hDlg, wParam) ? 0 : 1) ;
                          break ;

                     case IDD_ANSI:
                     case IDD_OEM:
                          CheckRadioButton (hDlg, IDD_ANSI, IDD_OEM, wParam) ;
                          lf.lfCharSet = (BYTE) (wParam == IDD_ANSI ? 0 : 255)
                          break ;

                     case IDD_QDRAFT:
                     case IDD_QDEF:
                     case IDD_QPROOF:
                          CheckRadioButton (hDlg, IDD_QDRAFT, IDD_QPROOF,
                                                                       wParam)
                          lf.lfQuality = (BYTE) (wParam - IDD_QDRAFT) ;
                          break ;

                     case IDD_PDEF:
                     case IDD_PFIXED:
                     case IDD_PVAR:
                          CheckRadioButton (hDlg, IDD_PDEF, IDD_PVAR, wParam)
                          lf.lfPitchAndFamily &= 0xF0 ;
                          lf.lfPitchAndFamily |= (BYTE) (wParam - IDD_PDEF) ;
                          break ;

                     case IDD_DONT:
                     case IDD_ROMAN:
                     case IDD_SWISS:
                     case IDD_MODERN:
                     case IDD_SCRIPT:
                     case IDD_DEC:
                          CheckRadioButton (hDlg, IDD_DONT, IDD_DEC, wParam) ;
                          lf.lfPitchAndFamily &= 0x0F ;
                          lf.lfPitchAndFamily |= (BYTE) (wParam-IDD_DONT << 4)
                          break ;

                     case IDD_OK:
                          ShowMetrics (hDlg) ;
                          InvalidateRect (GetParent (hDlg), NULL, TRUE) ;
                          break ;
                     }
                break ;

           default:
                return FALSE ;
           }
      return TRUE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char  szText [] =
                       "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPqQqRrSsTtUuVvWwXxYyZz"
      static short cxClient, cyClient ;
      HANDLE       hInstance ;
      HDC          hdc ;
      HFONT        hFont ;
      FARPROC      lpfnDlgProc ;
      PAINTSTRUCT  ps ;
      RECT         rect ;

      switch (message)
           {
           case WM_CREATE :
                hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;
                lpfnDlgProc = MakeProcInstance (DlgProc, hInstance) ;
                hDlg = CreateDialog (hInstance, szAppName, hwnd, lpfnDlgProc)
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hDlg) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                MySetMapMode (hdc) ;
                SetMapperFlags (hdc, dwAspectMatch) ;
                GetClientRect (hDlg, &rect) ;
                rect.bottom += 1 ;
                DPtoLP (hdc, (LPPOINT) &rect, 2) ;

                hFont = SelectObject (hdc, CreateFontIndirect (&lf)) ;

                TextOut (hdc, rect.left, rect.bottom, szText, 52) ;

                DeleteObject (SelectObject (hdc, hFont)) ;
                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POEPOEM.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP08\POEPOEM.C

 /*-------------------------------------------------
    POEPOEM.C -- Demonstrates User-Defined Resource
                 (c) Charles Petzold, 1990
   -------------------------------------------------*/

 #include <windows.h>
 #include "poepoem.h"

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;

 char   szAppName [10] ;
 char   szCaption [35] ;
 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           LoadString (hInstance, IDS_APPNAME, szAppName, sizeof szAppName) ;
           LoadString (hInstance, IDS_CAPTION, szCaption, sizeof szCaption) ;

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }
      else
           {
           GetInstanceData (hPrevInstance, szAppName, sizeof szAppName) ;
           GetInstanceData (hPrevInstance, szCaption, sizeof szCaption) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, szCaption,
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HANDLE hResource ;
      static HWND   hScroll ;
      static short  nPosition, cxChar, cyChar, cyClient, nNumLines, xScroll ;
      char          szPoemRes [15] ;
      char far      *lpText ;
      HDC           hdc ;
      PAINTSTRUCT   ps ;
      RECT          rect ;
      TEXTMETRIC    tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;
                ReleaseDC (hwnd, hdc) ;

                xScroll = GetSystemMetrics (SM_CXVSCROLL) ;

                hScroll = CreateWindow ("scrollbar", NULL,
                               WS_CHILD | WS_VISIBLE | SBS_VERT,
                               0, 0, 0, 0,
                               hwnd, 1, hInst, NULL) ;

                LoadString (hInst, IDS_POEMRES, szPoemRes, sizeof szPoemRes) ;
                hResource = LoadResource (hInst,
                            FindResource (hInst, szPoemRes, "TEXT")) ;

                lpText = LockResource (hResource) ;

                nNumLines = 0 ;

                while (*lpText != '\\' && *lpText != '\0')
                     {
                     if (*lpText == '\n')
                          nNumLines ++ ;
                     lpText = AnsiNext (lpText) ;
                     }
                *lpText = '\0' ;

                GlobalUnlock (hResource) ;

                SetScrollRange (hScroll, SB_CTL, 0, nNumLines, FALSE) ;
                SetScrollPos   (hScroll, SB_CTL, 0, FALSE) ;
                return 0 ;

           case WM_SIZE:
                MoveWindow (hScroll, LOWORD (lParam) - xScroll, 0,
                     xScroll, cyClient = HIWORD (lParam), TRUE) ;
                SetFocus (hwnd) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hScroll) ;
                return 0 ;

           case WM_VSCROLL:
                switch (wParam)
                     {
                     case SB_TOP:
                          nPosition = 0 ;
                          break ;
                     case SB_BOTTOM:
                          nPosition = nNumLines ;
                          break ;
                     case SB_LINEUP:
                          nPosition -= 1 ;
                          break ;
                     case SB_LINEDOWN:
                          nPosition += 1 ;
                          break ;
                     case SB_PAGEUP:
                          nPosition -= cyClient / cyChar ;
                          break ;
                     case SB_PAGEDOWN:
                          nPosition += cyClient / cyChar ;
                          break ;
                     case SB_THUMBPOSITION:
                          nPosition = LOWORD (lParam) ;
                          break ;
                     }
                nPosition = max (0, min (nPosition, nNumLines)) ;

                if (nPosition != GetScrollPos (hScroll, SB_CTL))
                     {
                     SetScrollPos (hScroll, SB_CTL, nPosition, TRUE) ;
                     InvalidateRect (hwnd, NULL, TRUE) ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                lpText = LockResource (hResource) ;

                GetClientRect (hwnd, &rect) ;
                rect.left += cxChar ;
                rect.top  += cyChar * (1 - nPosition) ;
                DrawText (hdc, lpText, -1, &rect, DT_EXTERNALLEADING) ;

                GlobalUnlock (hResource) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                FreeResource (hResource) ;
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POORMENU.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\POORMENU.C

 /*-----------------------------------------
    POORMENU.C -- The Poor Person's Menu
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>

 #define IDM_ABOUT   1
 #define IDM_HELP    2
 #define IDM_REMOVE  3

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 static char szAppName [] = "PoorMenu" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HMENU    hMenu ;
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "The Poor-Person's Menu",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      hMenu = GetSystemMenu (hwnd, FALSE) ;

      AppendMenu (hMenu, MF_SEPARATOR, 0,          NULL) ;
      AppendMenu (hMenu, MF_STRING,    IDM_ABOUT,  "About...") ;
      AppendMenu (hMenu, MF_STRING,    IDM_HELP,   "Help...") ;
      AppendMenu (hMenu, MF_STRING,    IDM_REMOVE, "Remove Additions") ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_SYSCOMMAND:
                switch (wParam)
                     {
                     case IDM_ABOUT:
                          MessageBox (hwnd, "A Poor-Person's Menu Program.",
                                      szAppName, MB_OK | MB_ICONEXCLAMATION) ;
                          return 0 ;

                     case IDM_HELP:
                          MessageBox (hwnd, "Help not yet implemented.",
                                      szAppName, MB_OK | MB_ICONEXCLAMATION) ;
                          return 0 ;

                     case IDM_REMOVE:
                          GetSystemMenu (hwnd, TRUE) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPMENU.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\POPMENU.C

 /*----------------------------------------
    POPMENU.C -- Popup Menu Demonstration
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include "popmenu.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 char   szAppName [] = "PopMenu" ;
 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, "Popup Menu Demonstration",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HMENU hMenu ;
      static int   wColorID [5] = { WHITE_BRUSH,  LTGRAY_BRUSH, GRAY_BRUSH,
                                    DKGRAY_BRUSH, BLACK_BRUSH } ;
      static WORD  wSelection = IDM_WHITE ;
      POINT        point ;

      switch (message)
           {
           case WM_CREATE:
                hMenu = LoadMenu (hInst, szAppName) ;
                hMenu = GetSubMenu (hMenu, 0) ;
                return 0 ;

           case WM_RBUTTONDOWN:
                point = MAKEPOINT (lParam) ;
                ClientToScreen (hwnd, &point) ;

                TrackPopupMenu (hMenu, 0, point.x, point.y, 0, hwnd, NULL) ;
                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_NEW:
                     case IDM_OPEN:
                     case IDM_SAVE:
                     case IDM_SAVEAS:
                     case IDM_UNDO:
                     case IDM_CUT:
                     case IDM_COPY:
                     case IDM_PASTE:
                     case IDM_CLEAR:
                          MessageBeep (0) ;
                          return 0 ;

                     case IDM_WHITE:          // Note: Logic below
                     case IDM_LTGRAY:         //   assumes that IDM_WHITE
                     case IDM_GRAY:           //   through IDM_BLACK are
                     case IDM_DKGRAY:         //   consecutive numbers in
                     case IDM_BLACK:          //   the order shown here.

                          CheckMenuItem (hMenu, wSelection, MF_UNCHECKED) ;
                          wSelection = wParam ;
                          CheckMenuItem (hMenu, wSelection, MF_CHECKED) ;

                          SetClassWord (hwnd, GCW_HBRBACKGROUND,
                               GetStockObject (wColorID [wParam - IDM_WHITE]))

                          InvalidateRect (hwnd, NULL, TRUE) ;
                          return 0 ;

                     case IDM_ABOUT:
                          MessageBox (hwnd, "Popup Menu Demonstration Program.
                                      szAppName, MB_ICONINFORMATION | MB_OK) ;
                          return 0 ;

                     case IDM_EXIT:
                          SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                          return 0 ;

                     case IDM_HELP:
                          MessageBox (hwnd, "Help not yet implemented.",
                                      szAppName, MB_ICONINFORMATION | MB_OK) ;
                          return 0 ;
                     }
                break ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPPAD.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\POPPAD.C

 /*---------------------------------------
    POPPAD.C -- Popup Editor
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>
 #include "poppad.h"
 #define  EDITID 1

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 BOOL ReadFile  (HANDLE, HWND, HWND, POFSTRUCT, char *, BOOL) ;
 BOOL WriteFile (HANDLE, HWND, HWND, POFSTRUCT, char *, BOOL) ;
 BOOL PrintFile (HANDLE, HWND, HWND, char *) ;

 LPSTR lstrrchr (LPSTR, char) ;

 char szAppName  [] = "PopPad" ;
 char szFileSpec [] = "*.TXT"  ;
 char szUntitled [] = "(untitled)" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      MSG      msg;
      HWND     hwnd ;
      HANDLE   hAccel ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, NULL,
                           WS_OVERLAPPEDWINDOW,
                           GetSystemMetrics (SM_CXSCREEN) / 4,
                           GetSystemMetrics (SM_CYSCREEN) / 4,
                           GetSystemMetrics (SM_CXSCREEN) / 2,
                           GetSystemMetrics (SM_CYSCREEN) / 2,
                           NULL, NULL, hInstance, lpszCmdLine) ;

      ShowWindow (hwnd, nCmdShow) ;

      UpdateWindow (hwnd);

      hAccel = LoadAccelerators (hInstance, szAppName) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (!TranslateAccelerator (hwnd, hAccel, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL AboutDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                return TRUE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDOK:
                          EndDialog (hDlg, 0) ;
                          return TRUE ;
                     }
                break ;
           }
      return FALSE ;
      }

 void DoCaption (HWND hwnd, char *szFileName)
      {
      char szCaption [40] ;

      wsprintf (szCaption, "%s - %s", (LPSTR) szAppName,
                (LPSTR) (szFileName [0] ? szFileName : szUntitled)) ;

      SetWindowText (hwnd, szCaption) ;
      }

 short AskAboutSave (HWND hwnd, char *szFileName)
      {
      char  szBuffer [40] ;
      short nReturn ;

      wsprintf (szBuffer, "Save current changes: %s",
                (LPSTR) (szFileName [0] ? szFileName : szUntitled)) ;

      if (IDYES == (nReturn = MessageBox (hwnd, szBuffer, szAppName,
                                     MB_YESNOCANCEL | MB_ICONQUESTION)))

           if (!SendMessage (hwnd, WM_COMMAND, IDM_SAVE, 0L))
                return IDCANCEL ;

      return nReturn ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL    bNeedSave = FALSE ;
      static char    szRealFileName [16] ;
      static FARPROC lpfnAboutDlgProc ;
      static HANDLE  hInst ;
      static HWND    hwndEdit ;
      char           szFileName [16] ;
      LONG           lSelect ;
      OFSTRUCT       of ;
      WORD           wEnable ;

      switch (message)
           {
           case WM_CREATE:
                hInst = ((LPCREATESTRUCT) lParam)->hInstance ;
                lpfnAboutDlgProc = MakeProcInstance (AboutDlgProc, hInst) ;

                hwndEdit = CreateWindow ("edit", NULL,
                          WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL |
                               WS_BORDER | ES_LEFT | ES_MULTILINE |
                               ES_AUTOHSCROLL | ES_AUTOVSCROLL,
                          0, 0, 0, 0,
                          hwnd, EDITID, hInst, NULL) ;

                SendMessage (hwndEdit, EM_LIMITTEXT, 32000, 0L) ;

                if (lstrlen (((LPCREATESTRUCT) lParam)->lpCreateParams))
                     {
                     OpenFile (((LPCREATESTRUCT) lParam)->lpCreateParams,
                                         &of, OF_PARSE) ;
                     lstrcpy (szFileName,
                               AnsiNext (lstrrchr (of.szPathName, '\\'))) ;

                     if (ReadFile (hInst, hwnd, hwndEdit, &of,
                               szFileName, FALSE))
                          lstrcpy (szRealFileName, szFileName) ;
                     }
                DoCaption (hwnd, szRealFileName) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndEdit) ;
                return 0 ;

           case WM_SIZE:
                MoveWindow (hwndEdit, 0, 0, LOWORD (lParam),
                                            HIWORD (lParam), TRUE) ;
                return 0 ;

           case WM_INITMENUPOPUP:
                if (lParam == 1)
                     {
                     EnableMenuItem (wParam, IDM_UNDO,
                          SendMessage (hwndEdit, EM_CANUNDO, 0, 0L) ?
                               MF_ENABLED : MF_GRAYED) ;

                     EnableMenuItem (wParam, IDM_PASTE,
                          IsClipboardFormatAvailable (CF_TEXT) ?
                               MF_ENABLED : MF_GRAYED) ;

                     lSelect = SendMessage (hwndEdit, EM_GETSEL, 0, 0L) ;

                     if (HIWORD (lSelect) == LOWORD (lSelect))
                          wEnable = MF_GRAYED ;
                     else
                          wEnable = MF_ENABLED ;

                     EnableMenuItem (wParam, IDM_CUT,   wEnable) ;
                     EnableMenuItem (wParam, IDM_COPY,  wEnable) ;
                     EnableMenuItem (wParam, IDM_CLEAR, wEnable) ;
                     }
                return 0 ;

           case WM_COMMAND :
                if (LOWORD (lParam) && wParam == EDITID)
                     {
                     switch (HIWORD (lParam))
                          {
                          case EN_UPDATE:
                               bNeedSave = TRUE ;
                               return 0 ;

                          case EN_ERRSPACE:
                               MessageBox (hwnd, "Edit control out of space.",
                                         szAppName, MB_OK | MB_ICONSTOP) ;
                               return 0 ;
                          }
                     break ;
                     }

                switch (wParam)
                     {
                     case IDM_NEW:
                          if (bNeedSave && IDCANCEL ==
                                    AskAboutSave (hwnd, szRealFileName))
                               return 0 ;

                          SetWindowText (hwndEdit, "\0") ;
                          szRealFileName [0] = '\0' ;
                          DoCaption (hwnd, szRealFileName) ;
                          bNeedSave = FALSE ;
                          return 0 ;

                     case IDM_OPEN:
                          if (bNeedSave && IDCANCEL ==
                                    AskAboutSave (hwnd, szRealFileName))
                               return 0 ;

                          if (ReadFile (hInst, hwnd, hwndEdit, &of,
                                         szFileName, TRUE))
                               {
                               lstrcpy (szRealFileName, szFileName) ;
                               DoCaption (hwnd, szRealFileName) ;
                               bNeedSave = FALSE ;
                               }

                          return 0 ;

                     case IDM_SAVE:
                          if (szRealFileName [0])
                               {
                               if (WriteFile (hInst, hwnd, hwndEdit, &of,
                                              szRealFileName, FALSE))
                                    {
                                    bNeedSave = FALSE ;
                                    return 1 ;
                                    }
                               return 0 ;
                               }
                                                   // fall through
                     case IDM_SAVEAS:
                          if (WriteFile (hInst, hwnd, hwndEdit, &of,
                                         szFileName, TRUE))
                               {
                               lstrcpy (szRealFileName, szFileName) ;
                               DoCaption (hwnd, szFileName) ;
                               bNeedSave = FALSE ;
                               return 1 ;
                               }
                          return 0 ;

                     case IDM_PRINT:
                          PrintFile (hInst, hwnd, hwndEdit,
                               szRealFileName [0] ? szRealFileName :
                                                    szUntitled) ;
                          return 0 ;

                     case IDM_EXIT:
                          SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                          return 0 ;

                     case IDM_ABOUT:
                          DialogBox (hInst, "AboutBox", hwnd,
                                    lpfnAboutDlgProc) ;
                          return 0 ;

                     case IDM_UNDO:
                          SendMessage (hwndEdit, WM_UNDO, 0, 0L) ;
                          return 0 ;

                     case IDM_CUT:
                          SendMessage (hwndEdit, WM_CUT, 0, 0L) ;
                          return 0 ;

                     case IDM_COPY:
                          SendMessage (hwndEdit, WM_COPY, 0, 0L) ;
                          return 0 ;

                     case IDM_PASTE:
                          SendMessage (hwndEdit, WM_PASTE, 0, 0L) ;
                          return 0 ;

                     case IDM_CLEAR:
                          SendMessage (hwndEdit, WM_CLEAR, 0, 0L) ;
                          return 0 ;

                     case IDM_SELALL:
                          SendMessage (hwndEdit, EM_SETSEL, 0,
                                         MAKELONG (0, 32767)) ;
                          return 0 ;
                     }
                break ;

           case WM_CLOSE:
                if (!bNeedSave || IDCANCEL !=
                          AskAboutSave (hwnd, szRealFileName))
                     DestroyWindow (hwnd) ;

                return 0 ;

           case WM_QUERYENDSESSION:
                if (!bNeedSave || IDCANCEL !=
                          AskAboutSave (hwnd, szRealFileName))
                     return 1L ;

                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPPAD.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\POPPAD.C

 /*---------------------------------------
    POPPAD.C -- Popup Editor
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>
 #include "poppad.h"
 #define  EDITID 1

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 BOOL ReadFile  (HANDLE, HWND, HWND, POFSTRUCT, char *, BOOL) ;
 BOOL WriteFile (HANDLE, HWND, HWND, POFSTRUCT, char *, BOOL) ;
 BOOL PrintFile (HANDLE, HWND, HWND, char *) ;

 LPSTR lstrrchr (LPSTR, char) ;

 char szAppName  [] = "PopPad" ;
 char szFileSpec [] = "*.TXT"  ;
 char szUntitled [] = "(untitled)" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      MSG      msg;
      HWND     hwnd ;
      HANDLE   hAccel ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, NULL,
                           WS_OVERLAPPEDWINDOW,
                           GetSystemMetrics (SM_CXSCREEN) / 4,
                           GetSystemMetrics (SM_CYSCREEN) / 4,
                           GetSystemMetrics (SM_CXSCREEN) / 2,
                           GetSystemMetrics (SM_CYSCREEN) / 2,
                           NULL, NULL, hInstance, lpszCmdLine) ;

      ShowWindow (hwnd, nCmdShow) ;

      UpdateWindow (hwnd);

      hAccel = LoadAccelerators (hInstance, szAppName) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (!TranslateAccelerator (hwnd, hAccel, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL AboutDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                return TRUE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDOK:
                          EndDialog (hDlg, 0) ;
                          return TRUE ;
                     }
                break ;
           }
      return FALSE ;
      }

 void DoCaption (HWND hwnd, char *szFileName)
      {
      char szCaption [40] ;

      wsprintf (szCaption, "%s - %s", (LPSTR) szAppName,
                (LPSTR) (szFileName [0] ? szFileName : szUntitled)) ;

      SetWindowText (hwnd, szCaption) ;
      }

 short AskAboutSave (HWND hwnd, char *szFileName)
      {
      char  szBuffer [40] ;
      short nReturn ;

      wsprintf (szBuffer, "Save current changes: %s",
                (LPSTR) (szFileName [0] ? szFileName : szUntitled)) ;

      if (IDYES == (nReturn = MessageBox (hwnd, szBuffer, szAppName,
                                     MB_YESNOCANCEL | MB_ICONQUESTION)))

           if (!SendMessage (hwnd, WM_COMMAND, IDM_SAVE, 0L))
                return IDCANCEL ;

      return nReturn ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL    bNeedSave = FALSE ;
      static char    szRealFileName [16] ;
      static FARPROC lpfnAboutDlgProc ;
      static HANDLE  hInst ;
      static HWND    hwndEdit ;
      char           szFileName [16] ;
      LONG           lSelect ;
      OFSTRUCT       of ;
      WORD           wEnable ;

      switch (message)
           {
           case WM_CREATE:
                hInst = ((LPCREATESTRUCT) lParam)->hInstance ;
                lpfnAboutDlgProc = MakeProcInstance (AboutDlgProc, hInst) ;

                hwndEdit = CreateWindow ("edit", NULL,
                          WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL |
                               WS_BORDER | ES_LEFT | ES_MULTILINE |
                               ES_AUTOHSCROLL | ES_AUTOVSCROLL,
                          0, 0, 0, 0,
                          hwnd, EDITID, hInst, NULL) ;

                SendMessage (hwndEdit, EM_LIMITTEXT, 32000, 0L) ;

                if (lstrlen (((LPCREATESTRUCT) lParam)->lpCreateParams))
                     {
                     OpenFile (((LPCREATESTRUCT) lParam)->lpCreateParams,
                                         &of, OF_PARSE) ;
                     lstrcpy (szFileName,
                               AnsiNext (lstrrchr (of.szPathName, '\\'))) ;

                     if (ReadFile (hInst, hwnd, hwndEdit, &of,
                               szFileName, FALSE))
                          lstrcpy (szRealFileName, szFileName) ;
                     }
                DoCaption (hwnd, szRealFileName) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndEdit) ;
                return 0 ;

           case WM_SIZE:
                MoveWindow (hwndEdit, 0, 0, LOWORD (lParam),
                                            HIWORD (lParam), TRUE) ;
                return 0 ;

           case WM_INITMENUPOPUP:
                if (lParam == 1)
                     {
                     EnableMenuItem (wParam, IDM_UNDO,
                          SendMessage (hwndEdit, EM_CANUNDO, 0, 0L) ?
                               MF_ENABLED : MF_GRAYED) ;

                     EnableMenuItem (wParam, IDM_PASTE,
                          IsClipboardFormatAvailable (CF_TEXT) ?
                               MF_ENABLED : MF_GRAYED) ;

                     lSelect = SendMessage (hwndEdit, EM_GETSEL, 0, 0L) ;

                     if (HIWORD (lSelect) == LOWORD (lSelect))
                          wEnable = MF_GRAYED ;
                     else
                          wEnable = MF_ENABLED ;

                     EnableMenuItem (wParam, IDM_CUT,   wEnable) ;
                     EnableMenuItem (wParam, IDM_COPY,  wEnable) ;
                     EnableMenuItem (wParam, IDM_CLEAR, wEnable) ;
                     }
                return 0 ;

           case WM_COMMAND :
                if (LOWORD (lParam) && wParam == EDITID)
                     {
                     switch (HIWORD (lParam))
                          {
                          case EN_UPDATE:
                               bNeedSave = TRUE ;
                               return 0 ;

                          case EN_ERRSPACE:
                               MessageBox (hwnd, "Edit control out of space.",
                                         szAppName, MB_OK | MB_ICONSTOP) ;
                               return 0 ;
                          }
                     break ;
                     }

                switch (wParam)
                     {
                     case IDM_NEW:
                          if (bNeedSave && IDCANCEL ==
                                    AskAboutSave (hwnd, szRealFileName))
                               return 0 ;

                          SetWindowText (hwndEdit, "\0") ;
                          szRealFileName [0] = '\0' ;
                          DoCaption (hwnd, szRealFileName) ;
                          bNeedSave = FALSE ;
                          return 0 ;

                     case IDM_OPEN:
                          if (bNeedSave && IDCANCEL ==
                                    AskAboutSave (hwnd, szRealFileName))
                               return 0 ;

                          if (ReadFile (hInst, hwnd, hwndEdit, &of,
                                         szFileName, TRUE))
                               {
                               lstrcpy (szRealFileName, szFileName) ;
                               DoCaption (hwnd, szRealFileName) ;
                               bNeedSave = FALSE ;
                               }

                          return 0 ;

                     case IDM_SAVE:
                          if (szRealFileName [0])
                               {
                               if (WriteFile (hInst, hwnd, hwndEdit, &of,
                                              szRealFileName, FALSE))
                                    {
                                    bNeedSave = FALSE ;
                                    return 1 ;
                                    }
                               return 0 ;
                               }
                                                   // fall through
                     case IDM_SAVEAS:
                          if (WriteFile (hInst, hwnd, hwndEdit, &of,
                                         szFileName, TRUE))
                               {
                               lstrcpy (szRealFileName, szFileName) ;
                               DoCaption (hwnd, szFileName) ;
                               bNeedSave = FALSE ;
                               return 1 ;
                               }
                          return 0 ;

                     case IDM_PRINT:
                          PrintFile (hInst, hwnd, hwndEdit,
                               szRealFileName [0] ? szRealFileName :
                                                    szUntitled) ;
                          return 0 ;

                     case IDM_EXIT:
                          SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                          return 0 ;

                     case IDM_ABOUT:
                          DialogBox (hInst, "AboutBox", hwnd,
                                    lpfnAboutDlgProc) ;
                          return 0 ;

                     case IDM_UNDO:
                          SendMessage (hwndEdit, WM_UNDO, 0, 0L) ;
                          return 0 ;

                     case IDM_CUT:
                          SendMessage (hwndEdit, WM_CUT, 0, 0L) ;
                          return 0 ;

                     case IDM_COPY:
                          SendMessage (hwndEdit, WM_COPY, 0, 0L) ;
                          return 0 ;

                     case IDM_PASTE:
                          SendMessage (hwndEdit, WM_PASTE, 0, 0L) ;
                          return 0 ;

                     case IDM_CLEAR:
                          SendMessage (hwndEdit, WM_CLEAR, 0, 0L) ;
                          return 0 ;

                     case IDM_SELALL:
                          SendMessage (hwndEdit, EM_SETSEL, 0,
                                         MAKELONG (0, 32767)) ;
                          return 0 ;
                     }
                break ;

           case WM_CLOSE:
                if (!bNeedSave || IDCANCEL !=
                          AskAboutSave (hwnd, szRealFileName))
                     DestroyWindow (hwnd) ;

                return 0 ;

           case WM_QUERYENDSESSION:
                if (!bNeedSave || IDCANCEL !=
                          AskAboutSave (hwnd, szRealFileName))
                     return 1L ;

                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPPAD1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP06\POPPAD1.C

 /*-------------------------------------------------------
    POPPAD1.C -- Popup Editor using child window edit box
                 (c) Charles Petzold, 1990
   -------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 char szAppName[] = "PopPad1" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, szAppName,
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           GetSystemMetrics (SM_CXSCREEN) / 2,
                           GetSystemMetrics (SM_CYSCREEN) / 2,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HWND hwndEdit ;

      switch (message)
           {
           case WM_CREATE:
                hwndEdit = CreateWindow ("edit", NULL,
                          WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL |
                               WS_BORDER | ES_LEFT | ES_MULTILINE |
                               ES_AUTOHSCROLL | ES_AUTOVSCROLL,
                          0, 0, 0, 0,
                          hwnd, 1,
                          ((LPCREATESTRUCT) lParam) -> hInstance, NULL) ;
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndEdit) ;
                return 0 ;

           case WM_SIZE:
                MoveWindow (hwndEdit, 0, 0, LOWORD (lParam),
                                            HIWORD (lParam), TRUE) ;
                return 0 ;

           case WM_COMMAND :
                if (wParam == 1 && HIWORD (lParam) == EN_ERRSPACE)
                     MessageBox (hwnd, "Edit control out of space.",
                               szAppName, MB_OK | MB_ICONSTOP) ;
                return 0 ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPPAD2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP09\POPPAD2.C

 /*-----------------------------------------------------
    POPPAD2.C -- Popup Editor Version 2 (includes menu)
                 (c) Charles Petzold, 1990
   -----------------------------------------------------*/

 #include <windows.h>
 #include "poppad2.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG);

 char szAppName [] = "PopPad2" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HANDLE   hAccel ;
      HWND     hwnd ;
      MSG      msg;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, szAppName,
                           WS_OVERLAPPEDWINDOW,
                           GetSystemMetrics (SM_CXSCREEN) / 4,
                           GetSystemMetrics (SM_CYSCREEN) / 4,
                           GetSystemMetrics (SM_CXSCREEN) / 2,
                           GetSystemMetrics (SM_CYSCREEN) / 2,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd);

      hAccel = LoadAccelerators (hInstance, szAppName) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           if (!TranslateAccelerator (hwnd, hAccel, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return msg.wParam ;
      }

 AskConfirmation (HWND hwnd)
      {
      return MessageBox (hwnd, "Really want to close PopPad2?",
                         szAppName, MB_YESNO | MB_ICONQUESTION) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HWND hwndEdit ;
      LONG        lSelect ;
      WORD        wEnable ;

      switch (message)
           {
           case WM_CREATE:
                hwndEdit = CreateWindow ("edit", NULL,
                          WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL |
                               WS_BORDER | ES_LEFT | ES_MULTILINE |
                               ES_AUTOHSCROLL | ES_AUTOVSCROLL,
                          0, 0, 0, 0,
                          hwnd, 1, ((LPCREATESTRUCT) lParam)->hInstance, NULL)
                return 0 ;

           case WM_SETFOCUS:
                SetFocus (hwndEdit) ;
                return 0 ;

           case WM_SIZE:
                MoveWindow (hwndEdit, 0, 0, LOWORD (lParam),
                                            HIWORD (lParam), TRUE) ;
                return 0 ;

           case WM_INITMENUPOPUP:
                if (lParam == 1)
                     {
                     EnableMenuItem (wParam, IDM_UNDO,
                          SendMessage (hwndEdit, EM_CANUNDO, 0, 0L) ?
                               MF_ENABLED : MF_GRAYED) ;

                     EnableMenuItem (wParam, IDM_PASTE,
                          IsClipboardFormatAvailable (CF_TEXT) ?
                               MF_ENABLED : MF_GRAYED) ;

                     lSelect = SendMessage (hwndEdit, EM_GETSEL, 0, 0L) ;

                     if (HIWORD (lSelect) == LOWORD (lSelect))
                          wEnable = MF_GRAYED ;
                     else
                          wEnable = MF_ENABLED ;

                     EnableMenuItem (wParam, IDM_CUT,   wEnable) ;
                     EnableMenuItem (wParam, IDM_COPY,  wEnable) ;
                     EnableMenuItem (wParam, IDM_CLEAR, wEnable) ;

                     return 0 ;
                     }
                break ;

           case WM_COMMAND :
                if (LOWORD (lParam))
                     {
                     if (wParam == 1 && HIWORD (lParam) == EN_ERRSPACE)
                          MessageBox (hwnd, "Edit control out of space.",
                                      szAppName, MB_OK | MB_ICONSTOP) ;

                     return 0 ;
                     }

                else switch (wParam)
                          {
                          case IDM_NEW:
                          case IDM_OPEN:
                          case IDM_SAVE:
                          case IDM_SAVEAS:
                          case IDM_PRINT:
                               MessageBeep (0) ;
                               return 0 ;

                          case IDM_EXIT:
                               SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
                               return 0 ;

                          case IDM_ABOUT:
                               MessageBox (hwnd,
                                    "POPPAD2 (c) Charles Petzold, 1990",
                                    szAppName, MB_OK | MB_ICONINFORMATION) ;
                               return 0 ;

                          case IDM_UNDO:
                               SendMessage (hwndEdit, WM_UNDO, 0, 0L) ;
                               return 0 ;

                          case IDM_CUT:
                               SendMessage (hwndEdit, WM_CUT, 0, 0L) ;
                               return 0 ;

                          case IDM_COPY:
                               SendMessage (hwndEdit, WM_COPY, 0, 0L) ;
                               return 0 ;

                          case IDM_PASTE:
                               SendMessage (hwndEdit, WM_PASTE, 0, 0L) ;
                               return 0 ;

                          case IDM_CLEAR:
                               SendMessage (hwndEdit, WM_CLEAR, 0, 0L) ;
                               return 0 ;

                          case IDM_SELALL:
                               SendMessage (hwndEdit, EM_SETSEL, 0,
                                            MAKELONG (0, 32767)) ;

                               return 0 ;
                          }
                break ;

           case WM_CLOSE:
                if (IDYES == AskConfirmation (hwnd))
                     DestroyWindow (hwnd) ;
                return 0 ;

           case WM_QUERYENDSESSION:
                if (IDYES == AskConfirmation (hwnd))
                     return 1L ;
                else
                     return 0 ;

           case WM_DESTROY :
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 POPPADF.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\POPPADF.C

 /*-----------------------------------
    POPPADF -- Popup Notepad File I/O
   -----------------------------------*/

 #include <windows.h>
                                         // in FILEDLG.C

 int DoFileOpenDlg (HANDLE, WORD, char *, char *, WORD,   char *, POFSTRUCT) ;
 int DoFileSaveDlg (HANDLE, WORD, char *, char *, WORD *, char *, POFSTRUCT) ;

 extern char szAppName  [] ;             // in POPPAD.C
 extern char szFileSpec [] ;

 long FileLength (HANDLE hFile)
      {
      long   lCurrentPos = _llseek (hFile, 0L, 1) ;
      long   lFileLength = _llseek (hFile, 0L, 2) ;

      _llseek (hFile, lCurrentPos, 0) ;

      return lFileLength ;
      }

 void OkMessageBox (HWND hwnd, char *szString, char *szFileName)
      {
      char szBuffer [40] ;

      wsprintf (szBuffer, szString, (LPSTR) szFileName) ;

      MessageBox (hwnd, szBuffer, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
      }

 BOOL ReadFile (HANDLE hInstance, HWND hwnd, HWND hwndEdit, POFSTRUCT pof,
          char *szFileName, BOOL bAskName)
      {
      DWORD  dwLength ;
      HANDLE hFile, hTextBuffer ;
      LPSTR  lpTextBuffer ;

      if (bAskName)
           {
           if (!DoFileOpenDlg (hInstance, hwnd, szFileSpec, szFileSpec + 1,
                                         0x4010, szFileName, pof))
                return FALSE ;
           }

      if (-1 == (hFile = OpenFile (szFileName, pof, OF_READ | OF_REOPEN)))
           {
           OkMessageBox (hwnd, "Cannot open file %s", szFileName) ;
           return FALSE ;
           }

      if ((dwLength = FileLength (hFile)) >= 32000)
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "File %s too large", szFileName) ;
           return FALSE ;
           }

      if (NULL == (hTextBuffer = GlobalAlloc (GHND, (DWORD) dwLength + 1)))
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "Cannot allocate memory for %s", szFileName) ;
           return FALSE ;
           }

      lpTextBuffer = GlobalLock (hTextBuffer) ;
      _lread (hFile, lpTextBuffer, (WORD) dwLength) ;
      _lclose (hFile) ;
      lpTextBuffer [(WORD) dwLength] = '\0' ;

      SetWindowText (hwndEdit, lpTextBuffer) ;
      GlobalUnlock (hTextBuffer) ;
      GlobalFree (hTextBuffer) ;

      return TRUE ;
      }

 BOOL WriteFile (HANDLE hInstance, HWND hwnd, HWND hwndEdit, POFSTRUCT pof,
     char *szFileName, BOOL bAskName)
      {
      char      szBuffer [40] ;
      HANDLE    hFile, hTextBuffer ;
      NPSTR     npTextBuffer ;
      WORD      wStatus, wLength ;

      if (bAskName)
           {
           if (!DoFileSaveDlg (hInstance, hwnd, szFileSpec, szFileSpec + 1,
                                    &wStatus, szFileName, pof))
                return FALSE ;

           if (wStatus == 1)
                {
                wsprintf (szBuffer, "Replace existing %s", (LPSTR) szFileName)
                if (IDNO == MessageBox (hwnd, szBuffer, szAppName,
                                              MB_YESNO | MB_ICONQUESTION))
                     return FALSE ;
                }
           }
      else
           OpenFile (szFileName, pof, OF_PARSE) ;

      if (-1 == (hFile = OpenFile (szFileName, pof, OF_CREATE | OF_REOPEN)))
           {
           OkMessageBox (hwnd, "Cannot create file %s", szFileName) ;
           return FALSE ;
           }

      wLength = GetWindowTextLength (hwndEdit) ;
      hTextBuffer = (HANDLE) SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L) ;
      npTextBuffer = LocalLock (hTextBuffer) ;

      if (wLength != _lwrite (hFile, npTextBuffer, wLength))
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "Cannot write file %s to disk", szFileName) ;
           return FALSE ;
           }

      _lclose (hFile) ;
      LocalUnlock (hTextBuffer) ;

      return TRUE ;
      }


 POPPADF.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\POPPADF.C

 /*-----------------------------------
    POPPADF -- Popup Notepad File I/O
   -----------------------------------*/

 #include <windows.h>
                                         // in FILEDLG.C

 int DoFileOpenDlg (HANDLE, WORD, char *, char *, WORD,   char *, POFSTRUCT) ;
 int DoFileSaveDlg (HANDLE, WORD, char *, char *, WORD *, char *, POFSTRUCT) ;

 extern char szAppName  [] ;             // in POPPAD.C
 extern char szFileSpec [] ;

 long FileLength (HANDLE hFile)
      {
      long   lCurrentPos = _llseek (hFile, 0L, 1) ;
      long   lFileLength = _llseek (hFile, 0L, 2) ;

      _llseek (hFile, lCurrentPos, 0) ;

      return lFileLength ;
      }

 void OkMessageBox (HWND hwnd, char *szString, char *szFileName)
      {
      static char szBuffer [40] ;

      wsprintf (szBuffer, szString, (LPSTR) szFileName) ;

      MessageBox (hwnd, szBuffer, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
      }

 BOOL ReadFile (HANDLE hInstance, HWND hwnd, HWND hwndEdit, POFSTRUCT pof,
          char *szFileName, BOOL bAskName)
      {
      DWORD  dwLength ;
      HANDLE hFile, hTextBuffer ;
      LPSTR  lpTextBuffer ;

      if (bAskName)
           {
           if (!DoFileOpenDlg (hInstance, hwnd, szFileSpec, szFileSpec + 1,
                                         0x4010, szFileName, pof))
                return FALSE ;
           }

      if (-1 == (hFile = OpenFile (szFileName, pof, OF_READ | OF_REOPEN)))
           {
           OkMessageBox (hwnd, "Cannot open file %s", szFileName) ;
           return FALSE ;
           }

      if ((dwLength = FileLength (hFile)) >= 32000)
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "File %s too large", szFileName) ;
           return FALSE ;
           }

      if (NULL == (hTextBuffer = GlobalAlloc (GHND, (DWORD) dwLength + 1)))
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "Cannot allocate memory for %s", szFileName) ;
           return FALSE ;
           }

      lpTextBuffer = GlobalLock (hTextBuffer) ;
      _lread (hFile, lpTextBuffer, (WORD) dwLength) ;
      _lclose (hFile) ;
      lpTextBuffer [(WORD) dwLength] = '\0' ;

      SetWindowText (hwndEdit, lpTextBuffer) ;
      GlobalUnlock (hTextBuffer) ;
      GlobalFree (hTextBuffer) ;

      return TRUE ;
      }

 BOOL WriteFile (HANDLE hInstance, HWND hwnd, HWND hwndEdit, POFSTRUCT pof,
     char *szFileName, BOOL bAskName)
      {
      char      szBuffer [40] ;
      HANDLE    hFile, hTextBuffer ;
      NPSTR     npTextBuffer ;
      WORD      wStatus, wLength ;

      if (bAskName)
           {
           if (!DoFileSaveDlg (hInstance, hwnd, szFileSpec, szFileSpec + 1,
                                    &wStatus, szFileName, pof))
                return FALSE ;

           if (wStatus == 1)
                {
                wsprintf (szBuffer, "Replace existing %s", (LPSTR) szFileName)
                if (IDNO == MessageBox (hwnd, szBuffer, szAppName,
                                              MB_YESNO | MB_ICONQUESTION))
                     return FALSE ;
                }
           }
      else
           OpenFile (szFileName, pof, OF_PARSE) ;

      if (-1 == (hFile = OpenFile (szFileName, pof, OF_CREATE | OF_REOPEN)))
           {
           OkMessageBox (hwnd, "Cannot create file %s", szFileName) ;
           return FALSE ;
           }

      wLength = GetWindowTextLength (hwndEdit) ;
      hTextBuffer = (HANDLE) SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L) ;
      npTextBuffer = LocalLock (hTextBuffer) ;

      if (wLength != _lwrite (hFile, npTextBuffer, wLength))
           {
           _lclose (hFile) ;
           OkMessageBox (hwnd, "Cannot write file %s to disk", szFileName) ;
           return FALSE ;
           }

      _lclose (hFile) ;
      LocalUnlock (hTextBuffer) ;

      return TRUE ;
      }


 POPPADP.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\POPPADP.C

 /*----------------------------------------------
    POPPADP.C -- Popup Editor Printing Functions
   ----------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "filedlg.h"                    // for IDD_FNAME definition

 extern char szAppName [] ;              // in POPPAD.C

 BOOL bUserAbort ;
 HWND hDlgPrint ;

 BOOL FAR PASCAL PrintDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE,
                                                             MF_GRAYED) ;
                return TRUE ;

           case WM_COMMAND:
                bUserAbort = TRUE ;
                EnableWindow (GetParent (hDlg), TRUE) ;
                DestroyWindow (hDlg) ;
                hDlgPrint = 0 ;
                return TRUE ;
           }
      return FALSE ;
      }

 BOOL FAR PASCAL AbortProc (HDC hPrinterDC, short nCode)
      {
      MSG   msg ;

      while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
           {
           if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return !bUserAbort ;
      }

 HDC GetPrinterDC (void)
      {
      static char szPrinter [80] ;
      char        *szDevice, *szDriver, *szOutput ;

      GetProfileString ("windows", "device", ",,,", szPrinter, 80) ;

      if ((szDevice = strtok (szPrinter, "," )) &&
          (szDriver = strtok (NULL,      ", ")) &&
          (szOutput = strtok (NULL,      ", ")))

                return CreateDC (szDriver, szDevice, szOutput, NULL) ;

      return 0 ;
      }

 BOOL PrintFile (HANDLE hInst, HWND hwnd, HWND hwndEdit, char *szFileName)
      {
      BOOL       bError = FALSE ;
      char       szMsg [40] ;
      FARPROC    lpfnAbortProc, lpfnPrintDlgProc ;
      HDC        hdcPrn ;
      NPSTR      psBuffer ;
      RECT       rect ;
      short      yChar, nCharsPerLine, nLinesPerPage,
                 nTotalLines, nTotalPages, nPage, nLine, nLineNum = 0 ;
      TEXTMETRIC tm ;

      if (0 == (nTotalLines = (short) SendMessage (hwndEdit,
                                              EM_GETLINECOUNT, 0, 0L)))
           return FALSE ;

      if (NULL == (hdcPrn = GetPrinterDC ()))
           return TRUE ;

      GetTextMetrics (hdcPrn, &tm) ;
      yChar = tm.tmHeight + tm.tmExternalLeading ;

      nCharsPerLine = GetDeviceCaps (hdcPrn, HORZRES) / tm.tmAveCharWidth ;
      nLinesPerPage = GetDeviceCaps (hdcPrn, VERTRES) / yChar ;
      nTotalPages   = (nTotalLines + nLinesPerPage - 1) / nLinesPerPage ;

      psBuffer = (NPSTR) LocalAlloc (LPTR, nCharsPerLine) ;

      EnableWindow (hwnd, FALSE) ;

      bUserAbort = FALSE ;
      lpfnPrintDlgProc = MakeProcInstance (PrintDlgProc, hInst) ;
      hDlgPrint = CreateDialog (hInst, "PrintDlgBox", hwnd, lpfnPrintDlgProc)
      SetDlgItemText (hDlgPrint, IDD_FNAME, szFileName) ;

      lpfnAbortProc = MakeProcInstance (AbortProc, hInst) ;
      Escape (hdcPrn, SETABORTPROC, 0, (LPSTR) lpfnAbortProc, NULL) ;

      strcat (strcat (strcpy (szMsg, szAppName), " - "), szFileName) ;

      if (Escape (hdcPrn, STARTDOC, strlen (szMsg), szMsg, NULL) > 0)
           {
           for (nPage = 0 ; nPage < nTotalPages ; nPage++)
                {
                for (nLine = 0 ; nLine < nLinesPerPage &&
                                 nLineNum < nTotalLines ; nLine++, nLineNum++)
                     {
                     *(short *) psBuffer = nCharsPerLine ;

                     TextOut (hdcPrn, 0, yChar * nLine, psBuffer,
                          (short) SendMessage (hwndEdit, EM_GETLINE,
                                         nLineNum, (LONG) (LPSTR) psBuffer)) ;
                     }

                if (Escape (hdcPrn, NEWFRAME, 0, NULL, (LPSTR) &rect) < 0)
                     {
                     bError = TRUE ;
                     break ;
                     }

                if (bUserAbort)
                     break ;
                }
           }
      else
           bError = TRUE ;

      if (!bError)
           Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;

      if (!bUserAbort)
           {
           EnableWindow (hwnd, TRUE) ;
           DestroyWindow (hDlgPrint) ;
           }

      if (bError || bUserAbort)
           {
           strcat (strcpy (szMsg, "Could not print: "), szFileName) ;
           MessageBox (hwnd, szMsg, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
           }

      LocalFree ((LOCALHANDLE) psBuffer) ;
      FreeProcInstance (lpfnPrintDlgProc) ;
      FreeProcInstance (lpfnAbortProc) ;
      DeleteDC (hdcPrn) ;

      return bError || bUserAbort ;
      }


 POPPADP0.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP10\POPPADP0.C

 /*---------------------------------------------------------
    POPPADP0.C -- Popup Notepad Printing -- dummy functions
   ---------------------------------------------------------*/

 #include <windows.h>

 extern char szAppName [] ;              // in POPPAD.C

 BOOL FAR PASCAL PrintDlgProc (HWND hDlg, WORD message,
                               WORD wParam, LONG lParam)
      {
      return FALSE ;
      }

 BOOL FAR PASCAL AbortProc (HDC hPrinterDC, short nCode)
      {
      return FALSE ;
      }

 BOOL PrintFile (HANDLE hInstance, HWND hwnd, HWND hwndEdit, char *szFileName)
      {
      MessageBox (hwnd, "Printing not yet implemented", szAppName,
                        MB_OK | MB_ICONEXCLAMATION) ;
      return FALSE ;
      }


 PRINT.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\PRINT.C

 /*-------------------------------------------------------------------
    PRINT.C -- Common Routines for Print1, Print2, Print3, and Print4
   -------------------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 BOOL PrintMyPage (HWND) ;

 extern HANDLE hInst ;
 extern char szAppName [] ;
 extern char szCaption [] ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, szCaption,
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      HMENU hMenu ;

      switch (message)
           {
           case WM_CREATE:
                hMenu = GetSystemMenu (hwnd, FALSE);
                AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
                AppendMenu (hMenu, 0, 1, "&Print") ;
                return 0 ;

           case WM_SYSCOMMAND:
                if (wParam == 1)
                     {
                     if (PrintMyPage (hwnd))
                          MessageBox (hwnd, "Could not print page",
                               szAppName, MB_OK | MB_ICONEXCLAMATION) ;
                     return 0 ;
                     }
                break ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 HDC GetPrinterDC (void)
      {
      static char szPrinter [80] ;
      char        *szDevice, *szDriver, *szOutput ;

      GetProfileString ("windows", "device", ",,,", szPrinter, 80) ;

      if ((szDevice = strtok (szPrinter, "," )) &&
          (szDriver = strtok (NULL,      ", ")) &&
          (szOutput = strtok (NULL,      ", ")))

                return CreateDC (szDriver, szDevice, szOutput, NULL) ;

      return 0 ;
      }

 void PageGDICalls (HDC hdcPrn, short cxPage, short cyPage)
      {
      static char szTextStr [] = "Hello Printer!" ;
      DWORD       dwExtent ;

      Rectangle (hdcPrn, 0, 0, cxPage, cyPage) ;

      MoveTo (hdcPrn, 0, 0) ;
      LineTo (hdcPrn, cxPage, cyPage) ;
      MoveTo (hdcPrn, cxPage, 0) ;
      LineTo (hdcPrn, 0, cyPage) ;

      SaveDC (hdcPrn) ;

      SetMapMode (hdcPrn, MM_ISOTROPIC) ;
      SetWindowExt   (hdcPrn, 1000, 1000) ;
      SetViewportExt (hdcPrn, cxPage / 2, -cyPage / 2) ;
      SetViewportOrg (hdcPrn, cxPage / 2,  cyPage / 2) ;

      Ellipse (hdcPrn, -500, 500, 500, -500) ;

      dwExtent = GetTextExtent (hdcPrn, szTextStr, sizeof szTextStr - 1) ;
      TextOut (hdcPrn, LOWORD (dwExtent) / 2, HIWORD (dwExtent) / 2,
               szTextStr, sizeof szTextStr - 1) ;

      RestoreDC (hdcPrn, -1) ;
      }


 PRINT1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\PRINT1.C

 /*---------------------------------------
    PRINT1.C -- Bare Bones Printing
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>

 HDC  GetPrinterDC (void) ;              // in PRINT.C
 void PageGDICalls (HDC, short, short) ;

 HANDLE hInst ;
 char   szAppName [] = "Print1" ;
 char   szCaption [] = "Print Program 1" ;

 BOOL PrintMyPage (HWND hwnd)
      {
      static char szMessage [] = "Print1: Printing" ;
      BOOL        bError = FALSE ;
      HDC         hdcPrn ;
      short       xPage, yPage ;

      if (NULL == (hdcPrn = GetPrinterDC ()))
           return TRUE ;

      xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
      yPage = GetDeviceCaps (hdcPrn, VERTRES) ;

      if (Escape (hdcPrn, STARTDOC, sizeof szMessage - 1, szMessage, NULL) > 0
           {
           PageGDICalls (hdcPrn, xPage, yPage) ;

           if (Escape (hdcPrn, NEWFRAME, 0, NULL, NULL) > 0)
                Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;
           else
                bError = TRUE ;
           }
      else
           bError = TRUE ;

      DeleteDC (hdcPrn) ;
      return bError ;
      }


 PRINT2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\PRINT2.C

 /*------------------------------------------
    PRINT2.C -- Printing with Abort Function
                (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>

 HDC  GetPrinterDC (void) ;              // in PRINT.C
 void PageGDICalls (HDC, short, short) ;

 HANDLE hInst ;
 char   szAppName [] = "Print2" ;
 char   szCaption [] = "Print Program 2 (Abort Function)" ;

 BOOL FAR PASCAL AbortProc (HDC hdcPrn, short nCode)
      {
      MSG   msg ;

      while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return TRUE ;
      }

 BOOL PrintMyPage (HWND hwnd)
      {
      static char szMessage [] = "Print2: Printing" ;
      BOOL        bError = FALSE ;
      FARPROC     lpfnAbortProc ;
      HDC         hdcPrn ;
      RECT        rect ;
      short       xPage, yPage ;

      if (NULL == (hdcPrn = GetPrinterDC ()))
           return TRUE ;

      xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
      yPage = GetDeviceCaps (hdcPrn, VERTRES) ;

      EnableWindow (hwnd, FALSE) ;

      lpfnAbortProc = MakeProcInstance (AbortProc, hInst) ;
      Escape (hdcPrn, SETABORTPROC, 0, (LPSTR) lpfnAbortProc, NULL) ;

      if (Escape (hdcPrn, STARTDOC, sizeof szMessage - 1, szMessage, NULL) > 0
           {
           PageGDICalls (hdcPrn, xPage, yPage) ;

           if (Escape (hdcPrn, NEWFRAME, 0, NULL, NULL) > 0)
                Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;
           else
                bError = TRUE ;
           }
      else
           bError = TRUE ;

      if (!bError)
           Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;

      FreeProcInstance (lpfnAbortProc) ;
      EnableWindow (hwnd, TRUE) ;
      DeleteDC (hdcPrn) ;
      return bError ;
      }


 PRINT3.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\PRINT3.C

 /*---------------------------------------
    PRINT3.C -- Printing with Dialog Box
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>

 HDC  GetPrinterDC (void) ;              // in PRINT.C
 void PageGDICalls (HDC, short, short) ;

 HANDLE hInst ;
 char   szAppName [] = "Print3" ;
 char   szCaption [] = "Print Program 3 (Dialog Box)" ;

 BOOL   bUserAbort ;
 HWND   hDlgPrint ;

 BOOL FAR PASCAL PrintDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                SetWindowText (hDlg, szAppName) ;
                EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE,
                                                             MF_GRAYED) ;
                return TRUE ;

           case WM_COMMAND:
                bUserAbort = TRUE ;
                EnableWindow (GetParent (hDlg), TRUE) ;
                DestroyWindow (hDlg) ;
                hDlgPrint = 0 ;
                return TRUE ;
           }
      return FALSE ;
      }

 BOOL FAR PASCAL AbortProc (HDC hdcPrn, short nCode)
      {
      MSG   msg ;

      while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
           {
           if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return !bUserAbort ;
      }

 BOOL PrintMyPage (HWND hwnd)
      {
      static char szMessage [] = "Print3: Printing" ;
      BOOL        bError = FALSE ;
      FARPROC     lpfnAbortProc, lpfnPrintDlgProc ;
      HDC         hdcPrn ;
      RECT        rect ;
      short       xPage, yPage ;

      if (NULL == (hdcPrn = GetPrinterDC ()))
           return TRUE ;

      xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
      yPage = GetDeviceCaps (hdcPrn, VERTRES) ;

      EnableWindow (hwnd, FALSE) ;

      bUserAbort = FALSE ;
      lpfnPrintDlgProc = MakeProcInstance (PrintDlgProc, hInst) ;
      hDlgPrint = CreateDialog (hInst, "PrintDlgBox", hwnd, lpfnPrintDlgProc)

      lpfnAbortProc = MakeProcInstance (AbortProc, hInst) ;
      Escape (hdcPrn, SETABORTPROC, 0, (LPSTR) lpfnAbortProc, NULL) ;

      if (Escape (hdcPrn, STARTDOC, sizeof szMessage - 1, szMessage, NULL) > 0
           {
           PageGDICalls (hdcPrn, xPage, yPage) ;

           if (Escape (hdcPrn, NEWFRAME, 0, NULL, NULL) > 0)
                Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;
           else
                bError = TRUE ;
           }
      else
           bError = TRUE ;

      if (!bUserAbort)
           {
           EnableWindow (hwnd, TRUE) ;
           DestroyWindow (hDlgPrint) ;
           }

      FreeProcInstance (lpfnPrintDlgProc) ;
      FreeProcInstance (lpfnAbortProc) ;
      DeleteDC (hdcPrn) ;

      return bError || bUserAbort ;
      }


 PRINT4.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP15\PRINT4.C

 /*---------------------------------------
    PRINT4.C -- Printing with Banding
                (c) Charles Petzold, 1990
   ---------------------------------------*/

 #include <windows.h>

 HDC  GetPrinterDC (void) ;              // in PRINT.C

 typedef BOOL (FAR PASCAL * ABORTPROC) (HDC, short) ;

 HANDLE hInst ;
 char   szAppName [] = "Print4" ;
 char   szCaption [] = "Print Program 4 (Banding)" ;

 BOOL   bUserAbort ;
 HWND   hDlgPrint ;

 BOOL FAR PASCAL PrintDlgProc (HWND hDlg, WORD message, WORD wParam, LONG lPar
      {
      switch (message)
           {
           case WM_INITDIALOG:
                SetWindowText (hDlg, szAppName) ;
                EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE,
                                                             MF_GRAYED) ;
                return TRUE ;

           case WM_COMMAND:
                bUserAbort = TRUE ;
                EnableWindow (GetParent (hDlg), TRUE) ;
                DestroyWindow (hDlg) ;
                hDlgPrint = 0 ;
                return TRUE ;
           }
      return FALSE ;
      }

 BOOL FAR PASCAL AbortProc (HDC hdcPrn, short nCode)
      {
      MSG   msg ;

      while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
           {
           if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
                {
                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           }
      return !bUserAbort ;
      }

 BOOL PrintMyPage (HWND hwnd)
      {
      static char szSpMsg [] = "Print4: Printing" ;
      static char szText  [] = "Hello Printer!" ;
      ABORTPROC   lpfnAbortProc ;
      BOOL        bError = FALSE ;
      DWORD       dwExtent ;
      FARPROC     lpfnPrintDlgProc ;
      HDC         hdcPrn ;
      POINT       ptExtent ;
      RECT        rect ;
      short       xPage, yPage ;

      if (NULL == (hdcPrn = GetPrinterDC ()))
           return TRUE ;

      xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
      yPage = GetDeviceCaps (hdcPrn, VERTRES) ;

      EnableWindow (hwnd, FALSE) ;

      bUserAbort = FALSE ;
      lpfnPrintDlgProc = MakeProcInstance (PrintDlgProc, hInst) ;
      hDlgPrint = CreateDialog (hInst, "PrintDlgBox", hwnd, lpfnPrintDlgProc)

      lpfnAbortProc = MakeProcInstance (AbortProc, hInst) ;
      Escape (hdcPrn, SETABORTPROC, 0, (LPSTR) lpfnAbortProc, NULL) ;

      if (Escape (hdcPrn, STARTDOC, sizeof szSpMsg - 1, szSpMsg, NULL) > 0 &&
          Escape (hdcPrn, NEXTBAND, 0, NULL, (LPSTR) &rect) > 0)
           {
           while (!IsRectEmpty (&rect) && !bUserAbort)
                {
                (*lpfnAbortProc) (hdcPrn, 0) ;

                Rectangle (hdcPrn, rect.left, rect.top, rect.right,
                                                        rect.bottom) ;
                (*lpfnAbortProc) (hdcPrn, 0) ;

                MoveTo (hdcPrn, 0, 0) ;
                LineTo (hdcPrn, xPage, yPage) ;

                (*lpfnAbortProc) (hdcPrn, 0) ;

                MoveTo (hdcPrn, xPage, 0) ;
                LineTo (hdcPrn, 0, yPage) ;

                SaveDC (hdcPrn) ;

                SetMapMode (hdcPrn, MM_ISOTROPIC) ;
                SetWindowExt   (hdcPrn, 1000, 1000) ;
                SetViewportExt (hdcPrn, xPage / 2, -yPage / 2) ;
                SetViewportOrg (hdcPrn, xPage / 2,  yPage / 2) ;

                (*lpfnAbortProc) (hdcPrn, 0) ;

                Ellipse (hdcPrn, -500, 500, 500, -500) ;

                (*lpfnAbortProc) (hdcPrn, 0) ;

                dwExtent = GetTextExtent (hdcPrn, szText, sizeof szText - 1) ;
                ptExtent = MAKEPOINT (dwExtent) ;
                TextOut (hdcPrn, -ptExtent.x / 2, ptExtent.y / 2, szText,
                                                   sizeof szText - 1) ;

                RestoreDC (hdcPrn, -1) ;

                (*lpfnAbortProc) (hdcPrn, 0) ;

                if (Escape (hdcPrn, NEXTBAND, 0, NULL, (LPSTR) &rect) < 0)
                     {
                     bError = TRUE ;
                     break ;
                     }
                }
           }
      else
           bError = TRUE ;

      if (!bError)
           {
           if (bUserAbort)
                Escape (hdcPrn, ABORTDOC, 0, NULL, NULL) ;
           else
                Escape (hdcPrn, ENDDOC, 0, NULL, NULL) ;
           }

      if (!bUserAbort)
           {
           EnableWindow (hwnd, TRUE) ;
           DestroyWindow (hDlgPrint) ;
           }

      FreeProcInstance (lpfnPrintDlgProc) ;
      FreeProcInstance (lpfnAbortProc) ;
      DeleteDC (hdcPrn) ;

      return bError || bUserAbort ;
      }


 RANDRECT.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP12\RANDRECT.C

 /*------------------------------------------
    RANDRECT.C -- Displays Random Rectangles
                  (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
 void DrawRectangle (HWND) ;

 short cxClient, cyClient ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "RandRect" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           !RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Random Rectangles",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (TRUE)
           {
           if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
                {
                if (msg.message == WM_QUIT)
                     break ;

                TranslateMessage (&msg) ;
                DispatchMessage (&msg) ;
                }
           else
                DrawRectangle (hwnd) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }

 void DrawRectangle (HWND hwnd)
      {
      HBRUSH hBrush ;
      HDC    hdc ;
      short  xLeft, xRight, yTop, yBottom, nRed, nGreen, nBlue ;

      xLeft   = rand () % cxClient ;
      xRight  = rand () % cxClient ;
      yTop    = rand () % cyClient ;
      yBottom = rand () % cyClient ;
      nRed    = rand () & 255 ;
      nGreen  = rand () & 255 ;
      nBlue   = rand () & 255 ;

      hdc = GetDC (hwnd) ;
      hBrush = CreateSolidBrush (RGB (nRed, nGreen, nBlue)) ;
      SelectObject (hdc, hBrush) ;

      Rectangle (hdc, min (xLeft, xRight), min (yTop, yBottom),
                      max (xLeft, xRight), max (yTop, yBottom)) ;

      ReleaseDC (hwnd, hdc) ;
      DeleteObject (hBrush) ;
      }


 RESOURC1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP08\RESOURC1.C

 /*-----------------------------------------------------------
    RESOURC1.C -- Icon and Cursor Demonstration Program No. 1
                  (c) Charles Petzold, 1990
   -----------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;

 char   szAppName [] = "Resourc1" ;
 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (hInstance, szAppName) ;
           wndclass.hbrBackground = COLOR_WINDOW + 1 ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, "Icon and Cursor Demo",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HICON hIcon ;
      static short cxIcon, cyIcon, cxClient, cyClient ;
      HDC          hdc ;
      RECT         rect ;
      PAINTSTRUCT  ps ;
      short        x, y ;

      switch (message)
           {
           case WM_CREATE:
                hIcon = LoadIcon (hInst, szAppName) ;
                cxIcon = GetSystemMetrics (SM_CXICON) ;
                cyIcon = GetSystemMetrics (SM_CYICON) ;
                return 0 ;

           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (y = cyIcon ; y < cyClient ; y += 2 * cyIcon)
                     for (x = cxIcon ; x < cxClient ; x += 2 * cxIcon)
                          DrawIcon (hdc, x, y, hIcon) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 RESOURC2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP08\RESOURC2.C

 /*-----------------------------------------------------------
    RESOURC2.C -- Icon and Cursor Demonstration Program No. 2
                  (c) Charles Petzold, 1990
   -----------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;

 char   szAppName[] = "Resourc2" ;
 HANDLE hInst ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HBITMAP  hBitmap ;
      HBRUSH   hBrush ;
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      hBitmap = LoadBitmap (hInstance, szAppName) ;
      hBrush = CreatePatternBrush (hBitmap) ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (hInstance, szAppName) ;
           wndclass.hbrBackground = hBrush ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hInst = hInstance ;

      hwnd = CreateWindow (szAppName, "Icon and Cursor Demo",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }

      DeleteObject (hBrush) ;       // clean-up
      DeleteObject (hBitmap) ;

      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HICON hIcon ;
      static short cxIcon, cyIcon, cxClient, cyClient ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      RECT         rect ;
      short        x, y ;

      switch (message)
           {
           case WM_CREATE:
                hIcon = LoadIcon (hInst, szAppName) ;
                cxIcon = GetSystemMetrics (SM_CXICON) ;
                cyIcon = GetSystemMetrics (SM_CYICON) ;
                return 0 ;

           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (y = cyIcon ; y < cyClient ; y += 2 * cyIcon)
                     for (x = cxIcon ; x < cxClient ; x += 2 * cxIcon)
                          DrawIcon (hdc, x, y, hIcon) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 ROP2LOOK.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP12\ROP2LOOK.C

 /*------------------------------------------
    ROP2LOOK.C -- ROP2 Demonstration Program
                  (c) Charles Petzold, 1990
   ------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Rop2Look" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "ROP2 Demonstration Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static LOGPEN lpBlack = { PS_SOLID, 1, 1, RGB (  0,   0,   0) },
                    lpWhite = { PS_SOLID, 1, 1, RGB (255, 255, 255) } ;
      static short  nDrawingMode = R2_COPYPEN ;
      HDC           hdc ;
      HMENU         hMenu ;
      HPEN          hPenBlack, hPenWhite ;
      PAINTSTRUCT   ps ;
      RECT          rect ;
      short         i ;

      switch (message)
           {
           case WM_COMMAND:
                hMenu = GetMenu (hwnd) ;
                CheckMenuItem (hMenu, nDrawingMode, MF_UNCHECKED) ;
                nDrawingMode = wParam ;
                CheckMenuItem (hMenu, nDrawingMode, MF_CHECKED) ;
                InvalidateRect (hwnd, NULL, FALSE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                hPenBlack = CreatePenIndirect (&lpBlack) ;
                hPenWhite = CreatePenIndirect (&lpWhite) ;

                SetMapMode (hdc, MM_ANISOTROPIC) ;
                GetClientRect (hwnd, &rect) ;
                SetViewportExt (hdc, rect.right, rect.bottom) ;
                SetWindowExt (hdc, 10, 4) ;

                for (i = 0 ; i < 10 ; i += 2)
                     {
                     SetRect (&rect, i, 0, i + 2, 4) ;
                     FillRect (hdc, &rect, GetStockObject (i / 2)) ;
                     }
                SetROP2 (hdc, nDrawingMode) ;

                SelectObject (hdc, hPenWhite) ;
                MoveTo (hdc, 1, 1) ;
                LineTo (hdc, 9, 1) ;

                SelectObject (hdc, hPenBlack) ;
                MoveTo (hdc, 1, 3) ;
                LineTo (hdc, 9, 3) ;

                EndPaint (hwnd, &ps) ;

                DeleteObject (hPenBlack) ;
                DeleteObject (hPenWhite) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SCRAMBLE.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP13\SCRAMBLE.C

 /*------------------------------------------------
    SCRAMBLE.C -- Scramble (and Unscramble) Screen
                  (c) Charles Petzold, 1990
   ------------------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>
 #define   NUM  200

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static short nKeep [NUM][4] ;
      HDC          hdc     = CreateDC ("DISPLAY", NULL, NULL, NULL) ;
      HDC          hdcMem  = CreateCompatibleDC (hdc) ;
      short        cxSize  = GetSystemMetrics (SM_CXSCREEN) / 10 ;
      short        cySize  = GetSystemMetrics (SM_CYSCREEN) / 10 ;
      HBITMAP      hBitmap = CreateCompatibleBitmap (hdc, cxSize, cySize) ;
      short        i, j, x1, y1, x2, y2 ;

      SelectObject (hdcMem, hBitmap) ;

      srand (LOWORD (GetCurrentTime ())) ;

      for (i = 0 ; i < 2 ; i++)
           for (j = 0 ; j < NUM ; j++)
                {
                if (i == 0)
                     {
                     nKeep [j] [0] = x1 = cxSize * (rand () % 10) ;
                     nKeep [j] [1] = y1 = cySize * (rand () % 10) ;
                     nKeep [j] [2] = x2 = cxSize * (rand () % 10) ;
                     nKeep [j] [3] = y2 = cySize * (rand () % 10) ;
                     }
                else
                     {
                     x1 = nKeep [NUM - 1 - j] [0] ;
                     y1 = nKeep [NUM - 1 - j] [1] ;
                     x2 = nKeep [NUM - 1 - j] [2] ;
                     y2 = nKeep [NUM - 1 - j] [3] ;
                     }
                BitBlt (hdcMem, 0, 0, cxSize, cySize, hdc,  x1, y1, SRCCOPY) ;
                BitBlt (hdc,  x1, y1, cxSize, cySize, hdc,  x2, y2, SRCCOPY) ;
                BitBlt (hdc,  x2, y2, cxSize, cySize, hdcMem, 0, 0, SRCCOPY) ;
                }
      return FALSE ;
      }


 SHOWBIT.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP19\SHOWBIT.C

 /*-----------------------------------------------------------
    SHOWBIT.C -- Shows bitmaps in BITLIB dynamic link library
                 (c) Charles Petzold, 1990
   -----------------------------------------------------------*/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static   char szAppName [] = "ShowBit" ;
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Show Bitmaps from BITLIB (Press Key)",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void DrawBitmap (HDC hdc, short xStart, short yStart, HBITMAP hBitmap)
      {
      BITMAP bm ;
      DWORD  dwSize ;
      HDC    hMemDC ;
      POINT  pt ;

      hMemDC = CreateCompatibleDC (hdc) ;
      SelectObject (hMemDC, hBitmap) ;
      GetObject (hBitmap, sizeof (BITMAP), (LPSTR) &bm) ;
      pt.x = bm.bmWidth ;
      pt.y = bm.bmHeight ;

      BitBlt (hdc, xStart, yStart, pt.x, pt.y, hMemDC, 0, 0, SRCCOPY) ;

      DeleteDC (hMemDC) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static HANDLE hLibrary ;
      static short  nCurrent = 1 ;
      HANDLE        hBitmap ;
      HDC           hdc ;
      PAINTSTRUCT   ps ;

      switch (message)
           {
           case WM_CREATE:
                if ((hLibrary = LoadLibrary ("BITLIB.DLL")) < 32)
                     MessageBeep (0) ;

                return 0 ;

           case WM_CHAR:
                if (hLibrary >= 32)
                     {
                     nCurrent ++ ;
                     InvalidateRect (hwnd, NULL, TRUE) ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                if (hLibrary >= 32)
                     {
                     if (NULL == (hBitmap = LoadBitmap (hLibrary,
                                              MAKEINTRESOURCE (nCurrent))))
                          {
                          nCurrent = 1 ;
                          hBitmap = LoadBitmap (hLibrary,
                                              MAKEINTRESOURCE (nCurrent)) ;
                          }

                     if (hBitmap)
                          DrawBitmap (hdc, 0, 0, hBitmap) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                if (hLibrary >= 32)
                     FreeLibrary (hLibrary) ;

                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SHOWPOP.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP17\SHOWPOP.C

 /*----------------------------------------
    SHOWPOP.C -- DDE Client using DDEPOP
                 (c) Charles Petzold, 1990
   ----------------------------------------*/

 #include <windows.h>
 #include <dde.h>
 #include <stdlib.h>
 #include <string.h>

 struct
      {
      char *szAbb ;
      char *szState ;
      long lPop ;
      }
      pop [] = {
               "AL", "Alabama",             0, "AK", "Alaska",              0,
               "AZ", "Arizona",             0, "AR", "Arkansas",            0,
               "CA", "California",          0, "CO", "Colorado",            0,
               "CT", "Connecticut",         0, "DE", "Delaware",            0,
               "DC", "Dist. of Columbia",   0, "FL", "Florida",             0,
               "GA", "Georgia",             0, "HI", "Hawaii",              0,
               "ID", "Idaho",               0, "IL", "Illinois",            0,
               "IN", "Indiana",             0, "IA", "Iowa",                0,
               "KS", "Kansas",              0, "KY", "Kentucky",            0,
               "LA", "Louisiana",           0, "ME", "Maine",               0,
               "MD", "Maryland",            0, "MA", "Massachusetts",       0,
               "MI", "Michigan",            0, "MN", "Minnesota",           0,
               "MS", "Mississippi",         0, "MO", "Missouri",            0,
               "MT", "Montana",             0, "NE", "Nebraska",            0,
               "NV", "Nevada",              0, "NH", "New Hampshire",       0,
               "NJ", "New Jersey",          0, "NM", "New Mexico",          0,
               "NY", "New York",            0, "NC", "North Carolina",      0,
               "ND", "North Dakota",        0, "OH", "Ohio",                0,
               "OK", "Oklahoma",            0, "OR", "Oregon",              0,
               "PA", "Pennsylvania",        0, "RI", "Rhode Island",        0,
               "SC", "South Carolina",      0, "SD", "South Dakota",        0,
               "TN", "Tennessee",           0, "TX", "Texas",               0,
               "UT", "Utah",                0, "VT", "Vermont",             0,
               "VA", "Virginia",            0, "WA", "Washington",          0,
               "WV", "West Virginia",       0, "WI", "Wisconsin",           0,
               "WY", "Wyoming",             0, "US", "United States Total", 0
               } ;

 #define NUM_STATES       (sizeof (pop) / sizeof (pop [0]))
 #define WM_USER_INITIATE (WM_USER + 1)
 #define DDE_TIMEOUT      3000

 long FAR PASCAL WndProc  (HWND, WORD, WORD, LONG) ;

 char   szAppName [] = "ShowPop" ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "DDE Client - US Population",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      SendMessage (hwnd, WM_USER_INITIATE, 0, 0L) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static BOOL   fDoingInitiate = TRUE ;
      static char   szServerApp [] = "DdePop",
                    szTopic     [] = "US_Population" ;
      static HWND   hwndServer = NULL ;
      static short  cxChar, cyChar ;
      ATOM          aApp, aTop, aItem ;
      char          szBuffer [24], szPopulation [16], szItem [16] ;
      DDEACK        DdeAck ;
      DDEDATA FAR   *lpDdeData ;
      DDEADVISE FAR *lpDdeAdvise ;
      DWORD         dwTime ;
      GLOBALHANDLE  hDdeAdvise, hDdeData ;
      HDC           hdc ;
      MSG           msg ;
      PAINTSTRUCT   ps ;
      short         i, x, y ;
      TEXTMETRIC    tm ;
      WORD          wStatus, cfFormat ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;
                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_USER_INITIATE:

                      // Broadcast WM_DDE_INITIATE message

                aApp = GlobalAddAtom (szServerApp) ;
                aTop = GlobalAddAtom (szTopic) ;

                SendMessage (0xFFFF, WM_DDE_INITIATE, hwnd,
                             MAKELONG (aApp, aTop)) ;

                      // If no response, try loading DDEPOP first

                if (hwndServer == NULL)
                     {
                     WinExec (szServerApp, SW_SHOWMINNOACTIVE) ;

                     SendMessage (0xFFFF, WM_DDE_INITIATE, hwnd,
                                  MAKELONG (aApp, aTop)) ;
                     }

                     // Delete the atoms

                GlobalDeleteAtom (aApp) ;
                GlobalDeleteAtom (aTop) ;
                fDoingInitiate = FALSE ;

                     // If still no response, display message box

                if (hwndServer == NULL)
                     {
                     MessageBox (hwnd, "Cannot connect with DDEPOP.EXE!",
                                 szAppName, MB_ICONEXCLAMATION | MB_OK) ;

                     return 0 ;
                     }

                     // Post WM_DDE_ADVISE messages

                for (i = 0 ; i < NUM_STATES ; i++)
                     {
                     hDdeAdvise = GlobalAlloc (GHND | GMEM_DDESHARE,
                                               sizeof (DDEADVISE)) ;

                     lpDdeAdvise = (DDEADVISE FAR *) GlobalLock (hDdeAdvise) ;

                     lpDdeAdvise->fAckReq   = TRUE ;
                     lpDdeAdvise->fDeferUpd = FALSE ;
                     lpDdeAdvise->cfFormat  = CF_TEXT ;

                     GlobalUnlock (hDdeAdvise) ;

                     aItem = GlobalAddAtom (pop[i].szAbb) ;

                     if (!PostMessage (hwndServer, WM_DDE_ADVISE, hwnd,
                                       MAKELONG (hDdeAdvise, aItem)))
                          {
                          GlobalFree (hDdeAdvise) ;
                          GlobalDeleteAtom (aItem) ;
                          break ;
                          }

                     DdeAck.fAck = FALSE ;

                     dwTime = GetCurrentTime () ;

                     while (GetCurrentTime () - dwTime < DDE_TIMEOUT)
                          {
                          if (PeekMessage (&msg, hwnd, WM_DDE_ACK,
                                           WM_DDE_ACK, PM_REMOVE))
                               {
                               GlobalDeleteAtom (HIWORD (msg.lParam)) ;

                               DdeAck = * (DDEACK *) & LOWORD (msg.lParam);

                               if (DdeAck.fAck == FALSE)
                                    GlobalFree (hDdeAdvise) ;

                               break ;
                               }
                          }

                     if (DdeAck.fAck == FALSE)
                          break ;

                     while (PeekMessage (&msg, hwnd, WM_DDE_FIRST,
                                         WM_DDE_LAST, PM_REMOVE))
                          {
                          DispatchMessage (&msg) ;
                          }
                     }

                if (i < NUM_STATES)
                     {
                     MessageBox (hwnd, "Failure on WM_DDE_ADVISE!",
                                 szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                     }
                return 0 ;

           case WM_DDE_ACK:

                     // In response to WM_DDE_INITIATE, save server window

                if (fDoingInitiate)
                     {
                     hwndServer = wParam ;
                     GlobalDeleteAtom (LOWORD (lParam)) ;
                     GlobalDeleteAtom (HIWORD (lParam)) ;
                     }
                return 0 ;

           case WM_DDE_DATA:

                     // wParam          -- sending window handle
                     // LOWORD (lParam) -- DDEDATA memory handle
                     // HIWORD (lParam) -- item atom

                hDdeData  = LOWORD (lParam) ;
                lpDdeData = (DDEDATA FAR *) GlobalLock (hDdeData) ;
                aItem     = HIWORD (lParam) ;

                     // Initialize DdeAck structure

                DdeAck.bAppReturnCode = 0 ;
                DdeAck.reserved       = 0 ;
                DdeAck.fBusy          = FALSE ;
                DdeAck.fAck           = FALSE ;

                     // Check for matching format and data item

                if (lpDdeData->cfFormat == CF_TEXT)
                     {
                     GlobalGetAtomName (aItem, szItem, sizeof (szItem)) ;

                     for (i = 0 ; i < NUM_STATES ; i++)
                          if (strcmp (szItem, pop[i].szAbb) == 0)
                               break ;

                     if (i < NUM_STATES)
                          {
                          lstrcpy (szPopulation, lpDdeData->Value) ;
                          pop[i].lPop = atol (szPopulation) ;
                          InvalidateRect (hwnd, NULL, FALSE) ;

                          DdeAck.fAck = TRUE ;
                          }
                     }

                     // Acknowledge if necessary

                if (lpDdeData->fAckReq == TRUE)
                     {
                     wStatus = * (WORD *) & DdeAck ;

                     if (!PostMessage (wParam, WM_DDE_ACK, hwnd,
                                       MAKELONG (wStatus, aItem)))
                          {
                          GlobalDeleteAtom (aItem) ;
                          GlobalUnlock (hDdeData) ;
                          GlobalFree (hDdeData) ;
                          return 0 ;
                          }
                     }
                else
                     {
                     GlobalDeleteAtom (aItem) ;
                     }

                     // Clean up

                if (lpDdeData->fRelease == TRUE || DdeAck.fAck == FALSE)
                     {
                     GlobalUnlock (hDdeData) ;
                     GlobalFree (hDdeData) ;
                     }
                else
                     {
                     GlobalUnlock (hDdeData) ;
                     }

                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (i = 0 ; i < NUM_STATES ; i++)
                     {
                     if (i < (NUM_STATES + 1) / 2)
                          {
                          x = cxChar ;
                          y = i * cyChar ;
                          }
                     else
                          {
                          x = 44 * cxChar ;
                          y = (i - (NUM_STATES + 1) / 2) * cyChar ;
                          }

                     TextOut (hdc, x, y, szBuffer,
                              wsprintf (szBuffer, "%-20s",
                                        (LPSTR) pop[i].szState)) ;

                     x += 36 * cxChar ;

                     SetTextAlign (hdc, TA_RIGHT | TA_TOP) ;

                     TextOut (hdc, x, y, szBuffer,
                              wsprintf (szBuffer, "%10ld", pop[i].lPop)) ;

                     SetTextAlign (hdc, TA_LEFT | TA_TOP) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DDE_TERMINATE:

                     // Respond with another WM_DDE_TERMINATE message

                PostMessage (hwndServer, WM_DDE_TERMINATE, hwnd, 0L) ;
                hwndServer = NULL ;
                return 0 ;

           case WM_CLOSE:
                if (hwndServer == NULL)
                     break ;

                     // Post WM_DDE_UNADVISE message

                PostMessage (hwndServer, WM_DDE_UNADVISE, hwnd,
                             MAKELONG (CF_TEXT, NULL)) ;

                dwTime = GetCurrentTime () ;

                while (GetCurrentTime () - dwTime < DDE_TIMEOUT)
                     {
                     if (PeekMessage (&msg, hwnd, WM_DDE_ACK,
                                      WM_DDE_ACK, PM_REMOVE))
                          break ;
                     }

                     // Post WM_DDE_TERMINATE message

                PostMessage (hwndServer, WM_DDE_TERMINATE, hwnd, 0L) ;

                dwTime = GetCurrentTime () ;

                while (GetCurrentTime () - dwTime < DDE_TIMEOUT)
                     {
                     if (PeekMessage (&msg, hwnd, WM_DDE_TERMINATE,
                                      WM_DDE_TERMINATE, PM_REMOVE))
                          break ;
                     }

                break ;             // for default processing

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 STRLIB.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP19\STRLIB.C

 /*------------------------------------------------
    STRLIB.C -- Library module for STRPROG program
                (c) Charles Petzold,  1990
   ------------------------------------------------*/

 #include <windows.h>

 typedef BOOL FAR PASCAL GETSTR (LPSTR, LPSTR) ;
 HANDLE hStrings [256] ;
 short  nTotal = 0 ;

 int FAR PASCAL LibMain (HANDLE hInstance, WORD wDataSeg, WORD wHeapSize,
                         LPSTR lpszCmdLine)
      {
      if (wHeapSize > 0)
           UnlockData (0) ;

      return 1 ;
      }

 BOOL FAR PASCAL AddString (LPSTR lpStringIn)
      {
      HANDLE hString ;
      NPSTR  npString ;
      short  i, nLength, nCompare ;

      if (nTotal == 255)
           return FALSE ;

      if (0 == (nLength = lstrlen (lpStringIn)))
           return FALSE ;

      if (NULL == (hString = LocalAlloc (LHND, 1 + nLength)))
           return FALSE ;

      npString = LocalLock (hString) ;
      lstrcpy (npString, lpStringIn) ;
      AnsiUpper (npString) ;
      LocalUnlock (hString) ;

      for (i = nTotal ; i > 0 ; i--)
           {
           npString = LocalLock (hStrings [i - 1]) ;
           nCompare = lstrcmpi (lpStringIn, npString) ;
           LocalUnlock (hStrings [i - 1]) ;

           if (nCompare > 0)
                {
                hStrings [i] = hString ;
                break ;
                }
           hStrings [i] = hStrings [i - 1] ;
           }

      if (i == 0)
           hStrings [0] = hString ;

      nTotal++ ;
      return TRUE ;
      }

 BOOL FAR PASCAL DeleteString (LPSTR lpStringIn)
      {
      NPSTR npString ;
      short i, j, nCompare ;

      if (0 == lstrlen (lpStringIn))
           return FALSE ;

      for (i = 0 ; i < nTotal ; i++)
           {
           npString = LocalLock (hStrings [i]) ;
           nCompare = lstrcmpi (npString, lpStringIn) ;
           LocalUnlock (hStrings [i]) ;

           if (nCompare == 0)
                break ;
           }

      if (i == nTotal)
           return FALSE ;

      for (j = i ; j < nTotal ; j++)
           hStrings [j] = hStrings [j + 1] ;

      nTotal-- ;
      return TRUE ;
      }

 short FAR PASCAL GetStrings (GETSTR lpfnGetStrCallBack, LPSTR lpParam)
      {
      BOOL  bReturn ;
      NPSTR npString ;
      short i ;

      for (i = 0 ; i < nTotal ; i++)
           {
           npString = LocalLock (hStrings [i]) ;
           bReturn = (*lpfnGetStrCallBack) ((LPSTR) npString, lpParam) ;
           LocalUnlock (hStrings [i]) ;

           if (bReturn == FALSE)
                return i + 1 ;
           }
      return nTotal ;
      }


 STRPROG.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP19\STRPROG.C

 /*--------------------------------------------------------
    STRPROG.C -- Program using STRLIB dynamic link library
                 (c) Charles Petzold, 1990
   --------------------------------------------------------*/

 #include <windows.h>
 #include <string.h>
 #include "strprog.h"

 #define MAXLEN 32
 #define WM_DATACHANGE WM_USER

 typedef struct
      {
      HDC   hdc ;
      short xText ;
      short yText ;
      short xStart ;
      short yStart ;
      short xIncr ;
      short yIncr ;
      short xMax ;
      short yMax ;
      }
      CBPARM ;

 BOOL  FAR PASCAL AddString    (LPSTR) ;      // functions in STRLIB
 BOOL  FAR PASCAL DeleteString (LPSTR) ;
 short FAR PASCAL GetStrings   (FARPROC, CBPARM FAR *) ;

 long  FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 char  szAppName [] = "StrProg" ;
 char  szString  [MAXLEN] ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      HWND     hwnd ;
      MSG      msg ;
      WNDCLASS wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "DLL Demonstration Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 BOOL FAR PASCAL DlgProc (HWND hDlg, WORD message, WORD wParam, LONG lParam)
      {
      switch (message)
           {
           case WM_INITDIALOG:
                SendDlgItemMessage (hDlg, IDD_STRING, EM_LIMITTEXT,
                                    MAXLEN - 1, 0L);
                return TRUE ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDOK:
                          GetDlgItemText (hDlg, IDD_STRING, szString, MAXLEN)
                          EndDialog (hDlg, TRUE) ;
                          return TRUE ;

                     case IDCANCEL:
                          EndDialog (hDlg, FALSE) ;
                          return TRUE ;
                     }
           }
      return FALSE ;
      }

 BOOL FAR PASCAL EnumCallBack (HWND hwnd, LONG lParam)
      {
      char szClassName [16] ;

      GetClassName (hwnd, szClassName, sizeof szClassName) ;

      if (0 == strcmp (szClassName, szAppName))
           SendMessage (hwnd, WM_DATACHANGE, 0, 0L) ;

      return TRUE ;
      }

 BOOL FAR PASCAL GetStrCallBack (LPSTR lpString, CBPARM FAR *lpcbp)
      {
      TextOut (lpcbp->hdc, lpcbp->xText, lpcbp->yText,
               lpString, lstrlen (lpString)) ;

      if ((lpcbp->yText += lpcbp->yIncr) > lpcbp->yMax)
           {
           lpcbp->yText = lpcbp->yStart ;
           if ((lpcbp->xText += lpcbp->xIncr) > lpcbp->xMax)
                return FALSE ;
           }
      return TRUE ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static FARPROC lpfnDlgProc, lpfnGetStrCallBack, lpfnEnumCallBack ;
      static HANDLE  hInst ;
      static short   cxChar, cyChar, cxClient, cyClient ;
      CBPARM         cbparam ;
      HDC            hdc ;
      PAINTSTRUCT    ps ;
      TEXTMETRIC     tm ;

      switch (message)
           {
           case WM_CREATE:
                hInst = ((LPCREATESTRUCT) lParam)->hInstance ;

                lpfnDlgProc        = MakeProcInstance (DlgProc, hInst) ;
                lpfnGetStrCallBack = MakeProcInstance (GetStrCallBack, hInst)
                lpfnEnumCallBack   = MakeProcInstance (EnumCallBack, hInst) ;

                hdc = GetDC (hwnd) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;
                ReleaseDC (hwnd, hdc) ;

                return 0 ;

           case WM_COMMAND:
                switch (wParam)
                     {
                     case IDM_ENTER:
                          if (DialogBox (hInst, "EnterDlg", hwnd, lpfnDlgProc)
                               {
                               if (AddString (szString))
                                    EnumWindows (lpfnEnumCallBack, 0L) ;
                               else
                                    MessageBeep (0) ;
                               }
                          break ;

                     case IDM_DELETE:
                          if (DialogBox (hInst, "DeleteDlg", hwnd, lpfnDlgProc
                               {
                               if (DeleteString (szString))
                                    EnumWindows (lpfnEnumCallBack, 0L) ;
                               else
                                    MessageBeep (0) ;
                               }
                          break ;
                     }
                return 0 ;

           case WM_SIZE:
                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;
                return 0 ;

           case WM_DATACHANGE:
                InvalidateRect (hwnd, NULL, TRUE) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                cbparam.hdc   = hdc ;
                cbparam.xText = cbparam.xStart = cxChar ;
                cbparam.yText = cbparam.yStart = cyChar ;
                cbparam.xIncr = cxChar * MAXLEN ;
                cbparam.yIncr = cyChar ;
                cbparam.xMax  = cbparam.xIncr * (1 + cxClient / cbparam.xIncr)
                cbparam.yMax  = cyChar * (cyClient / cyChar - 1) ;

                GetStrings (lpfnGetStrCallBack, &cbparam) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SYSMETS.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP03\SYSMETS.C

 /*-----------------------------------------------------
    SYSMETS.C -- System Metrics Display Program (Final)
                 (c) Charles Petzold, 1990
   -----------------------------------------------------*/

 #include <windows.h>
 #include "sysmets.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "SysMets" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "System Metrics",
                           WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short  cxChar, cxCaps, cyChar, cxClient, cyClient, nMaxWidth,
                    nVscrollPos, nVscrollMax, nHscrollPos, nHscrollMax ;
      char          szBuffer[10] ;
      HDC           hdc ;
      short         i, x, y, nPaintBeg, nPaintEnd, nVscrollInc, nHscrollInc ;
      PAINTSTRUCT   ps ;
      TEXTMETRIC    tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;

                nMaxWidth = 40 * cxChar + 18 * cxCaps ;
                return 0 ;

           case WM_SIZE:
                cyClient = HIWORD (lParam) ;
                cxClient = LOWORD (lParam) ;

          nVscrollMax = max (0, NUMLINES + 2 - cyClient / cyChar) ;
                nVscrollPos = min (nVscrollPos, nVscrollMax) ;

                SetScrollRange (hwnd, SB_VERT, 0, nVscrollMax, FALSE) ;
                SetScrollPos   (hwnd, SB_VERT, nVscrollPos, TRUE) ;

          nHscrollMax = max (0, 2 + (nMaxWidth - cxClient) / cxChar) ;
                nHscrollPos = min (nHscrollPos, nHscrollMax) ;

                SetScrollRange (hwnd, SB_HORZ, 0, nHscrollMax, FALSE) ;
                SetScrollPos   (hwnd, SB_HORZ, nHscrollPos, TRUE) ;
                return 0 ;

           case WM_VSCROLL:
                switch (wParam)
                     {
                     case SB_TOP:
                          nVscrollInc = -nVscrollPos ;
                          break ;

                     case SB_BOTTOM:
                          nVscrollInc = nVscrollMax - nVscrollPos ;
                          break ;

                     case SB_LINEUP:
                          nVscrollInc = -1 ;
                          break ;

                     case SB_LINEDOWN:
                          nVscrollInc = 1 ;
                          break ;

                     case SB_PAGEUP:
                          nVscrollInc = min (-1, -cyClient / cyChar) ;
                          break ;

                     case SB_PAGEDOWN:
                          nVscrollInc = max (1, cyClient / cyChar) ;
                          break ;

                     case SB_THUMBTRACK:
                          nVscrollInc = LOWORD (lParam) - nVscrollPos ;
                          break ;

                     default:
                          nVscrollInc = 0 ;
                     }
                if (nVscrollInc = max (-nVscrollPos,
                          min (nVscrollInc, nVscrollMax - nVscrollPos)))
                     {
                     nVscrollPos += nVscrollInc ;
                     ScrollWindow (hwnd, 0, -cyChar * nVscrollInc, NULL, NULL)
                     SetScrollPos (hwnd, SB_VERT, nVscrollPos, TRUE) ;
                     UpdateWindow (hwnd) ;
                     }
                return 0 ;

           case WM_HSCROLL:
                switch (wParam)
                     {
                     case SB_LINEUP:
                          nHscrollInc = -1 ;
                          break ;

                     case SB_LINEDOWN:
                          nHscrollInc = 1 ;
                          break ;

                     case SB_PAGEUP:
                          nHscrollInc = -8 ;
                          break ;

                     case SB_PAGEDOWN:
                          nHscrollInc = 8 ;
                          break ;

                     case SB_THUMBPOSITION:
                          nHscrollInc = LOWORD (lParam) - nHscrollPos ;
                          break ;

                     default:
                          nHscrollInc = 0 ;
                     }
                if (nHscrollInc = max (-nHscrollPos,
                          min (nHscrollInc, nHscrollMax - nHscrollPos)))
                     {
                     nHscrollPos += nHscrollInc ;
                     ScrollWindow (hwnd, -cxChar * nHscrollInc, 0, NULL, NULL)
                     SetScrollPos (hwnd, SB_HORZ, nHscrollPos, TRUE) ;
                     }
                return 0 ;

           case WM_KEYDOWN:
                switch (wParam)
                     {
                     case VK_HOME:
                          SendMessage (hwnd, WM_VSCROLL, SB_TOP, 0L) ;
                          break ;

                     case VK_END:
                          SendMessage (hwnd, WM_VSCROLL, SB_BOTTOM, 0L) ;
                          break ;

                     case VK_PRIOR:
                          SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0L) ;
                          break ;

                     case VK_NEXT:
                          SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0L) ;
                          break ;

                     case VK_UP:
                          SendMessage (hwnd, WM_VSCROLL, SB_LINEUP, 0L) ;
                          break ;

                     case VK_DOWN:
                          SendMessage (hwnd, WM_VSCROLL, SB_LINEDOWN, 0L) ;
                          break ;

                     case VK_LEFT:
                          SendMessage (hwnd, WM_HSCROLL, SB_PAGEUP, 0L) ;
                          break ;

                     case VK_RIGHT:
                          SendMessage (hwnd, WM_HSCROLL, SB_PAGEDOWN, 0L) ;
                          break ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                nPaintBeg = max (0, nVscrollPos + ps.rcPaint.top / cyChar - 1)
                nPaintEnd = min (NUMLINES,
                                 nVscrollPos + ps.rcPaint.bottom / cyChar) ;

                for (i = nPaintBeg ; i < nPaintEnd ; i++)
                     {
                     x = cxChar * (1 - nHscrollPos) ;
                     y = cyChar * (1 - nVscrollPos + i) ;

                     TextOut (hdc, x, y,
                              sysmetrics[i].szLabel,
            lstrlen (sysmetrics[i].szLabel)) ;

                     TextOut (hdc, x + 18 * cxCaps, y,
                              sysmetrics[i].szDesc,
            lstrlen (sysmetrics[i].szDesc)) ;

                     SetTextAlign (hdc, TA_RIGHT | TA_TOP) ;

                     TextOut (hdc, x + 18 * cxCaps + 40 * cxChar, y,
                              szBuffer,
                              wsprintf (szBuffer, "%5d",
           GetSystemMetrics (sysmetrics[i].nIndex))) ;

                     SetTextAlign (hdc, TA_LEFT | TA_TOP) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }

      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SYSMETS1.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP02\SYSMETS1.C

 /*----------------------------------------------------
    SYSMETS1.C -- System Metrics Display Program No. 1
                  (c) Charles Petzold, 1990
   ----------------------------------------------------*/

 #include <windows.h>
 #include "sysmets.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "SysMets1" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Get System Metrics No. 1",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short cxChar, cxCaps, cyChar ;
      char         szBuffer[10] ;
      HDC          hdc ;
      short        i ;
      PAINTSTRUCT  ps ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (i = 0 ; i < NUMLINES ; i++)
                     {
         TextOut (hdc, cxChar, cyChar * (1 + i),
                              sysmetrics[i].szLabel,
            lstrlen (sysmetrics[i].szLabel)) ;

         TextOut (hdc, cxChar + 18 * cxCaps, cyChar * (1 + i),
                              sysmetrics[i].szDesc,
            lstrlen (sysmetrics[i].szDesc)) ;

                     SetTextAlign (hdc, TA_RIGHT | TA_TOP) ;

         TextOut (hdc, cxChar + 18 * cxCaps + 40 * cxChar,
            cyChar * (1 + i), szBuffer,
                              wsprintf (szBuffer, "%5d",
           GetSystemMetrics (sysmetrics[i].nIndex))) ;

                     SetTextAlign (hdc, TA_LEFT | TA_TOP) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }

      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SYSMETS2.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP02\SYSMETS2.C

 /*----------------------------------------------------
    SYSMETS2.C -- System Metrics Display Program No. 2
                  (c) Charles Petzold, 1990
   ----------------------------------------------------*/

 #include <windows.h>
 #include "sysmets.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "SysMets2" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Get System Metrics No. 2",
                           WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short cxChar, cxCaps, cyChar, cxClient, cyClient, nVscrollPos ;
      char         szBuffer[10] ;
      HDC          hdc ;
      short        i, y ;
      PAINTSTRUCT  ps ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;

                SetScrollRange (hwnd, SB_VERT, 0, NUMLINES, FALSE) ;
                SetScrollPos   (hwnd, SB_VERT, nVscrollPos, TRUE) ;
                return 0 ;

           case WM_SIZE:
                cyClient = HIWORD (lParam) ;
                cxClient = LOWORD (lParam) ;
                return 0 ;

           case WM_VSCROLL:
                switch (wParam)
                     {
                     case SB_LINEUP:
                          nVscrollPos -= 1 ;
                          break ;

                     case SB_LINEDOWN:
                          nVscrollPos += 1 ;
                          break ;

                     case SB_PAGEUP:
                          nVscrollPos -= cyClient / cyChar ;
                          break ;

                     case SB_PAGEDOWN:
                          nVscrollPos += cyClient / cyChar ;
                          break ;

                     case SB_THUMBPOSITION:
                          nVscrollPos = LOWORD (lParam) ;
                          break ;

                     default:
                          break ;
                     }
                nVscrollPos = max (0, min (nVscrollPos, NUMLINES)) ;

                if (nVscrollPos != GetScrollPos (hwnd, SB_VERT))
                     {
                     SetScrollPos (hwnd, SB_VERT, nVscrollPos, TRUE) ;
                     InvalidateRect (hwnd, NULL, TRUE) ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                for (i = 0 ; i < NUMLINES ; i++)
                     {
                     y = cyChar * (1 - nVscrollPos + i) ;

                     TextOut (hdc, cxChar, y,
                              sysmetrics[i].szLabel,
            lstrlen (sysmetrics[i].szLabel)) ;

                     TextOut (hdc, cxChar + 18 * cxCaps, y,
                              sysmetrics[i].szDesc,
            lstrlen (sysmetrics[i].szDesc)) ;

                     SetTextAlign (hdc, TA_RIGHT | TA_TOP) ;

                     TextOut (hdc, cxChar + 18 * cxCaps + 40 * cxChar, y,
                              szBuffer,
                              wsprintf (szBuffer, "%5d",
           GetSystemMetrics (sysmetrics[i].nIndex))) ;

                     SetTextAlign (hdc, TA_LEFT | TA_TOP) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }

      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 SYSMETS3.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP02\SYSMETS3.C

 /*----------------------------------------------------
    SYSMETS3.C -- System Metrics Display Program No. 3
                  (c) Charles Petzold, 1990
   ----------------------------------------------------*/

 #include <windows.h>
 #include "sysmets.h"

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "SysMets3" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Get System Metrics No. 3",
                           WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static short cxChar, cxCaps, cyChar, cxClient, cyClient, nMaxWidth,
                   nVscrollPos, nVscrollMax, nHscrollPos, nHscrollMax ;
      char         szBuffer[10] ;
      HDC          hdc ;
      short        i, x, y, nPaintBeg, nPaintEnd, nVscrollInc, nHscrollInc ;
      PAINTSTRUCT  ps ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;

                nMaxWidth = 40 * cxChar + 18 * cxCaps ;
                return 0 ;

           case WM_SIZE:
                cyClient = HIWORD (lParam) ;
                cxClient = LOWORD (lParam) ;

          nVscrollMax = max (0, NUMLINES + 2 - cyClient / cyChar) ;
                nVscrollPos = min (nVscrollPos, nVscrollMax) ;

                SetScrollRange (hwnd, SB_VERT, 0, nVscrollMax, FALSE) ;
                SetScrollPos   (hwnd, SB_VERT, nVscrollPos, TRUE) ;

          nHscrollMax = max (0, 2 + (nMaxWidth - cxClient) / cxChar) ;
                nHscrollPos = min (nHscrollPos, nHscrollMax) ;

                SetScrollRange (hwnd, SB_HORZ, 0, nHscrollMax, FALSE) ;
                SetScrollPos   (hwnd, SB_HORZ, nHscrollPos, TRUE) ;
                return 0 ;

           case WM_VSCROLL:
                switch (wParam)
                     {
                     case SB_TOP:
                          nVscrollInc = -nVscrollPos ;
                          break ;

                     case SB_BOTTOM:
                          nVscrollInc = nVscrollMax - nVscrollPos ;
                          break ;

                     case SB_LINEUP:
                          nVscrollInc = -1 ;
                          break ;

                     case SB_LINEDOWN:
                          nVscrollInc = 1 ;
                          break ;

                     case SB_PAGEUP:
                          nVscrollInc = min (-1, -cyClient / cyChar) ;
                          break ;

                     case SB_PAGEDOWN:
                          nVscrollInc = max (1, cyClient / cyChar) ;
                          break ;

                     case SB_THUMBTRACK:
                          nVscrollInc = LOWORD (lParam) - nVscrollPos ;
                          break ;

                     default:
                          nVscrollInc = 0 ;
                     }
                if (nVscrollInc = max (-nVscrollPos,
                          min (nVscrollInc, nVscrollMax - nVscrollPos)))
                     {
                     nVscrollPos += nVscrollInc ;
                     ScrollWindow (hwnd, 0, -cyChar * nVscrollInc, NULL, NULL)
                     SetScrollPos (hwnd, SB_VERT, nVscrollPos, TRUE) ;
                     UpdateWindow (hwnd) ;
                     }
                return 0 ;

           case WM_HSCROLL:
                switch (wParam)
                     {
                     case SB_LINEUP:
                          nHscrollInc = -1 ;
                          break ;

                     case SB_LINEDOWN:
                          nHscrollInc = 1 ;
                          break ;

                     case SB_PAGEUP:
                          nHscrollInc = -8 ;
                          break ;

                     case SB_PAGEDOWN:
                          nHscrollInc = 8 ;
                          break ;

                     case SB_THUMBPOSITION:
                          nHscrollInc = LOWORD (lParam) - nHscrollPos ;
                          break ;

                     default:
                          nHscrollInc = 0 ;
                     }
                if (nHscrollInc = max (-nHscrollPos,
                          min (nHscrollInc, nHscrollMax - nHscrollPos)))
                     {
                     nHscrollPos += nHscrollInc ;
                     ScrollWindow (hwnd, -cxChar * nHscrollInc, 0, NULL, NULL)
                     SetScrollPos (hwnd, SB_HORZ, nHscrollPos, TRUE) ;
                     }
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;

                nPaintBeg = max (0, nVscrollPos + ps.rcPaint.top / cyChar - 1)
                nPaintEnd = min (NUMLINES,
                                 nVscrollPos + ps.rcPaint.bottom / cyChar) ;

                for (i = nPaintBeg ; i < nPaintEnd ; i++)
                     {
                     x = cxChar * (1 - nHscrollPos) ;
                     y = cyChar * (1 - nVscrollPos + i) ;

                     TextOut (hdc, x, y,
                              sysmetrics[i].szLabel,
            lstrlen (sysmetrics[i].szLabel)) ;

                     TextOut (hdc, x + 18 * cxCaps, y,
                              sysmetrics[i].szDesc,
            lstrlen (sysmetrics[i].szDesc)) ;

                     SetTextAlign (hdc, TA_RIGHT | TA_TOP) ;

                     TextOut (hdc, x + 18 * cxCaps + 40 * cxChar, y,
                              szBuffer,
                              wsprintf (szBuffer, "%5d",
           GetSystemMetrics (sysmetrics[i].nIndex))) ;

                     SetTextAlign (hdc, TA_LEFT | TA_TOP) ;
                     }

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }

      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 TYPE.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP03\TYPE.C

 /*-------------------------------------
    TYPE.C -- Typing Program
              (c) Charles Petzold, 1990
   -------------------------------------*/

 #include <windows.h>
 #include <stdlib.h>

 #define BUFFER(x,y) *(pBuffer + y * cxBuffer + x)

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "Type" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "Typing Program",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char *pBuffer = NULL ;
      static int  cxChar, cyChar, cxClient, cyClient, cxBuffer, cyBuffer,
                  xCaret, yCaret ;
      HDC         hdc ;
      int         x, y, i ;
      PAINTSTRUCT ps ;
      TEXTMETRIC  tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;

                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight ;

                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_SIZE:
                                    // obtain window size in pixels

                cxClient = LOWORD (lParam) ;
                cyClient = HIWORD (lParam) ;

                                    // calculate window size in characters

                cxBuffer = max (1, cxClient / cxChar) ;
                cyBuffer = max (1, cyClient / cyChar) ;

                                    // allocate memory for buffer and clear it

                if (pBuffer != NULL)
                     free (pBuffer) ;

                if ((LONG) cxBuffer * cyBuffer > 65535L ||
                          (pBuffer = malloc (cxBuffer * cyBuffer)) == NULL)

                     MessageBox (hwnd, "Window too large.  Cannot "
                                       "allocate enough memory.", "Type",
                                 MB_ICONEXCLAMATION | MB_OK) ;

                else
                     for (y = 0 ; y < cyBuffer ; y++)
                          for (x = 0 ; x < cxBuffer ; x++)
                               BUFFER(x,y) = ' ' ;

                                    // set caret to upper left corner
                xCaret = 0 ;
                yCaret = 0 ;

                if (hwnd == GetFocus ())
                     SetCaretPos (xCaret * cxChar, yCaret * cyChar) ;

                return 0 ;

           case WM_SETFOCUS:
                                    // create and show the caret

                CreateCaret (hwnd, NULL, cxChar, cyChar) ;
                SetCaretPos (xCaret * cxChar, yCaret * cyChar) ;
                ShowCaret (hwnd) ;
                return 0 ;

           case WM_KILLFOCUS:
                                    // hide and destroy the caret
                HideCaret (hwnd) ;
                DestroyCaret () ;
                return 0 ;

           case WM_KEYDOWN:
                switch (wParam)
                     {
                     case VK_HOME:
                          xCaret = 0 ;
                          break ;

                     case VK_END:
                          xCaret = cxBuffer - 1 ;
                          break ;

                     case VK_PRIOR:
                          yCaret = 0 ;
                          break ;

                     case VK_NEXT:
                          yCaret = cyBuffer - 1 ;
                          break ;

                     case VK_LEFT:
                          xCaret = max (xCaret - 1, 0) ;
                          break ;

                     case VK_RIGHT:
                          xCaret = min (xCaret + 1, cxBuffer - 1) ;
                          break ;

                     case VK_UP:
                          yCaret = max (yCaret - 1, 0) ;
                          break ;

                     case VK_DOWN:
                          yCaret = min (yCaret + 1, cyBuffer - 1) ;
                          break ;

                     case VK_DELETE:
                          for (x = xCaret ; x < cxBuffer - 1 ; x++)
                               BUFFER (x, yCaret) = BUFFER (x + 1, yCaret) ;

                          BUFFER (cxBuffer - 1, yCaret) = ' ' ;

                          HideCaret (hwnd) ;
                          hdc = GetDC (hwnd) ;

                          SelectObject (hdc,
                               GetStockObject (SYSTEM_FIXED_FONT)) ;

                          TextOut (hdc, xCaret * cxChar, yCaret * cyChar,
                                   & BUFFER (xCaret, yCaret),
                                   cxBuffer - xCaret) ;

                          ShowCaret (hwnd) ;
                          ReleaseDC (hwnd, hdc) ;
                          break ;
                     }

                SetCaretPos (xCaret * cxChar, yCaret * cyChar) ;
                return 0 ;

           case WM_CHAR:
                for (i = 0 ; i < LOWORD (lParam) ; i++)
                     {
                     switch (wParam)
                          {
                          case '\b' :                    // backspace
                               if (xCaret > 0)
                                    {
                                    xCaret-- ;
                                    SendMessage (hwnd, WM_KEYDOWN,
                                                 VK_DELETE, 1L) ;
                                    }
                               break ;

                          case '\t' :                    // tab
                               do
                                    {
                                    SendMessage (hwnd, WM_CHAR, ' ', 1L) ;
                                    }
                               while (xCaret % 8 != 0) ;
                               break ;

                          case '\n' :                    // line feed
                               if (++yCaret == cyBuffer)
                                    yCaret = 0 ;
                               break ;

                          case '\r' :                    // carriage return
                               xCaret = 0 ;

                               if (++yCaret == cyBuffer)
                                    yCaret = 0 ;
                               break ;

                          case '\x1B' :                  // escape
                               for (y = 0 ; y < cyBuffer ; y++)
                                    for (x = 0 ; x < cxBuffer ; x++)
                                         BUFFER (x, y) = ' ' ;

                               xCaret = 0 ;
                               yCaret = 0 ;

                               InvalidateRect (hwnd, NULL, FALSE) ;
                               break ;

                          default:                       // character codes
                               BUFFER (xCaret, yCaret) = (char) wParam ;

                               HideCaret (hwnd) ;
                               hdc = GetDC (hwnd) ;

                               SelectObject (hdc,
                                    GetStockObject (SYSTEM_FIXED_FONT)) ;

                               TextOut (hdc, xCaret * cxChar, yCaret * cyChar,
                                        & BUFFER (xCaret, yCaret), 1) ;

                               ShowCaret (hwnd) ;
                               ReleaseDC (hwnd, hdc) ;

                               if (++xCaret == cxBuffer)
                                    {
                                    xCaret = 0 ;

                                    if (++yCaret == cyBuffer)
                                         yCaret = 0 ;
                                    }
                               break ;
                          }
                     }

                SetCaretPos (xCaret * cxChar, yCaret * cyChar) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                for (y = 0 ; y < cyBuffer ; y++)
                     TextOut (hdc, 0, y * cyChar, & BUFFER(0,y), cxBuffer) ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }


 WHATSIZE.C
 CD-ROM Disc Path:   \SAMPCODE\PROGWIN\CHAP11\WHATSIZE.C

 /*-----------------------------------------
    WHATSIZE.C -- What Size is the Window?
                  (c) Charles Petzold, 1990
   -----------------------------------------*/

 #include <windows.h>
 #include <stdio.h>

 long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;

 int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
                     LPSTR lpszCmdLine, int nCmdShow)
      {
      static char szAppName[] = "WhatSize" ;
      HWND        hwnd ;
      MSG         msg ;
      WNDCLASS    wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           RegisterClass (&wndclass) ;
           }

      hwnd = CreateWindow (szAppName, "What Size is the Window?",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           CW_USEDEFAULT, CW_USEDEFAULT,
                           NULL, NULL, hInstance, NULL) ;

      ShowWindow (hwnd, nCmdShow) ;
      UpdateWindow (hwnd) ;

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void Show (HWND hwnd, HDC hdc, short xText, short yText, short nMapMode,
            char *szMapMode)
      {
      char szBuffer [60] ;
      RECT rect ;

      SaveDC (hdc) ;

      SetMapMode (hdc, nMapMode) ;
      GetClientRect (hwnd, &rect) ;
      DPtoLP (hdc, (LPPOINT) &rect, 2) ;

      RestoreDC (hdc, -1) ;

      TextOut (hdc, xText, yText, szBuffer,
                sprintf (szBuffer, "%-20s %7d %7d %7d %7d", szMapMode,
                     rect.left, rect.right, rect.top, rect.bottom)) ;
      }

 long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
      {
      static char  szHeading [] =
                     "Mapping Mode            Left   Right     Top  Bottom" ;
      static char  szUndLine [] =
                     "------------            ----   -----     ---  ------" ;
      static short cxChar, cyChar ;
      HDC          hdc ;
      PAINTSTRUCT  ps ;
      TEXTMETRIC   tm ;

      switch (message)
           {
           case WM_CREATE:
                hdc = GetDC (hwnd) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                GetTextMetrics (hdc, &tm) ;
                cxChar = tm.tmAveCharWidth ;
                cyChar = tm.tmHeight + tm.tmExternalLeading ;

                ReleaseDC (hwnd, hdc) ;
                return 0 ;

           case WM_PAINT:
                hdc = BeginPaint (hwnd, &ps) ;
                SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;

                SetMapMode (hdc, MM_ANISOTROPIC) ;
                SetWindowExt (hdc, 1, 1) ;
                SetViewportExt (hdc, cxChar, cyChar) ;

                TextOut (hdc, 1, 1, szHeading, sizeof szHeading - 1) ;
                TextOut (hdc, 1, 2, szUndLine, sizeof szUndLine - 1) ;

                Show (hwnd, hdc, 1, 3, MM_TEXT,      "TEXT (pixels)") ;
                Show (hwnd, hdc, 1, 4, MM_LOMETRIC,  "LOMETRIC (.1 mm)") ;
                Show (hwnd, hdc, 1, 5, MM_HIMETRIC,  "HIMETRIC (.01 mm)") ;
                Show (hwnd, hdc, 1, 6, MM_LOENGLISH, "LOENGLISH (.01 in)") ;
                Show (hwnd, hdc, 1, 7, MM_HIENGLISH, "HIENGLISH (.001 in)") ;
                Show (hwnd, hdc, 1, 8, MM_TWIPS,     "TWIPS (1/1440 in)") ;

                EndPaint (hwnd, &ps) ;
                return 0 ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                return 0 ;
           }
      return DefWindowProc (hwnd, message, wParam, lParam) ;
      }




 Object Linking & Embedding: Sample `C' Source Code


 CLDEMO.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\CLIENT\CLDEMO.C

 //---------------------------------------------------------------------------
 // cldemo.c
 //
 // Copyright (c) Microsoft Corporation, 1990-
 //---------------------------------------------------------------------------

 //---------------------------------------------------------------------------
 // include files
 //---------------------------------------------------------------------------

 #include "windows.h"
 #include "ecd.h"
 #include "cldemo.h"
 #include "client.h"

 // ----- constants ---------------------------------------------------------
 #define szLessonClass  "Lesson1Class"
 #define szItemClass    "ItemClass"
 #define szMenuName     "Menu"
 #define szTitle        "Client - %s"
 #define szDefOpen      "test.cl1"
 #define szUntitled     "Untitled"
 #define szSave         "Save Changes to %s ?"
 #define szInvalidFn    "Invalid file name"
 #define szNoFile       "No filename specified."
 #define szFnError      "File Error"
 #define dxCascade      20
 #define dyCascade      20
 #define dxInflate      5
 #define dyInflate      5
 #define cbFnMax        255
 #define szMsgMax       100
 #define szMaxClassName 20
 #define MaxChildWnd     20


 // ----- globals -----------------------------------------------------------



 HANDLE  hAccTable;
 HWND    hwndMain;
 POINT   ptAnchor;                // top-left corner of a new window
 char    rgchFilename[cbFnMax]; // file's name
 char    rgchOpenName[cbFnMax];
 BOOL    fDirty = FALSE;   // true if any modification has been made to the fi
 WORD    cfLink, cfOwnerLink, cfNative;
 HWND  hInst;
 HWND  hwndEdit = NULL;
 HANDLE hEditBuffer = NULL;
 FARPROC lpEditWndProc;
 BOOL fInsUpdate = FALSE;
 char szInsFileName[cbFnMax];
 HWND hUndoitem = NULL;

 HWND rgchChildWnd[MaxChildWnd];
 int irgchChild = 0;
 int nObjDestroy = 0;

 // BOOL fObjectClose = FALSE;

 extern HANDLE      hObjectUndo;
 extern LPECDOBJECT     lpObjectUndo;
 extern BOOL            fEcdrelease;
 extern BOOL            fEcdReleaseError;
 extern BOOL            fEcdReleaseStat;

 // ----- Local functions ---------------------------------------------------
 BOOL InitApplication (HANDLE hInstance);
 BOOL InitInstance (HANDLE hInstance, int nCmdShow);
 void TermInstance (void);
 void GetFromClipboard (HWND, WORD);
 void PutOnClipboard(HWND, WORD);
 void ResetAnchor (PPOINT);
 void MoveAnchor (PPOINT, PRECT, PPOINT);
 void SetNullFilename (HWND);
 void SetFilename (HWND, char*);
 BOOL SaveAsNeeded (HWND);
 BOOL New (HWND);
 BOOL Open (HWND);
 BOOL Save (HWND);
 BOOL SaveAs (HWND);
 BOOL WriteToFile (HWND);
 BOOL ReadFromFile (HWND, int);
 void CleanHwnd (HWND hwnd);
 ECDSTATUS CreateObject(WORD wParam, PITEM pitem);
 void CallPrint();
 void RemoveObjUndo();
 void PrintError(ECDSTATUS stat);
 void PrintWindowTitle(PITEM pitem, HWND hwnd);

 VOID TestEqual();

 void PrepareUndoClear(PITEM pitem);
 void GetUndo(PITEM pitem);
 ECDSTATUS CopyLink(PITEM pCopy);
 VOID WaitForRelease(PITEM pitem);
 HWND GetTopChild();
 HWND GetNextWnd(LPINT i);

 long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ItemWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL AboutDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL SaveAsDlgProc(HWND, unsigned, WORD, LONG);
 int  FAR PASCAL OpenDlgProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL InsFileProc (HWND, unsigned, WORD, LONG);

 //---------------------------------------------------------------------------
 // WinMain
 // Purpose: Wins the Main
 //---------------------------------------------------------------------------
 int PASCAL
 WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine, int nCmdShow
 {
     MSG msg;
   BOOL fMsg;
    hInst = hInstance;

     // initialize the application
   fMsg = SetMessageQueue(32);

     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);

     // initialize the instance
     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     // initialize the client module
     if (!InitClient (hInstance))
         return FALSE;

     // Main message pump
     while (GetMessage(&msg, NULL, NULL, NULL))
         {
         if (!TranslateAccelerator(hwndMain, hAccTable, &msg))
             {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
             }
         }

     // clean up
     TermInstance ();
     TermClient ();

     return (msg.wParam);
 }

 //---------------------------------------------------------------------------
 // CreateItemWindow
 // Purpose: Create a window in which we'll put an object
 // Returns: handle to the newly created window
 //---------------------------------------------------------------------------
 HWND CreateItemWindow (HWND hwndParent, BOOL fIconic, LPRECT lprect)
 {
     RECT  rc;
     POINT ptSize;

     // Find a window position and size
     // We do all the previous work even if lprect != NULL
     // create the window
     return (CreateWindow(
         szItemClass,
         "",                  // Window Title
         WS_DLGFRAME | WS_CHILD | WS_CLIPSIBLINGS |
           WS_THICKFRAME |  WS_VISIBLE | WS_CAPTION | WS_MINIMIZEBOX |
       (fIconic ? WS_MINIMIZE : 0),
 //          WS_THICKFRAME | (fVisible ? WS_VISIBLE : 0),
         NULL,
         NULL,
         200,
         200,
         hwndParent,
         NULL,
         hInst,
         NULL));
 }


 //---------------------------------------------------------------------------
 // InitApplication
 // Purpose: Register windows' classes
 // Return: TRUE if successful, FALSE otherwise.
 //---------------------------------------------------------------------------
 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  szMenuName;
     wc.lpszClassName = szLessonClass;

     if (!RegisterClass(&wc))
         return FALSE;

     wc.style   = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
     wc.hIcon   =  NULL;
     wc.cbWndExtra = sizeof(HANDLE); // used to store a handle to the window's
                                     //  content
     wc.lpszMenuName = NULL;
     wc.lpszClassName = szItemClass;
     wc.lpfnWndProc   = ItemWndProc;

     if (!RegisterClass(&wc))
         return FALSE;
 }



 //---------------------------------------------------------------------------
 // InitInstance
 // Purpose: Create the main window
 // Return: TRUE if successful, FALSE otherwise.
 //---------------------------------------------------------------------------
 BOOL InitInstance(HANDLE hInstance, int nCmdShow)
 {

     hAccTable = LoadAccelerators(hInstance, "Accelerators");

     ResetAnchor(&ptAnchor);

     // register clipboard formats.
     cfLink      = RegisterClipboardFormat("ObjectLink");
     cfOwnerLink = RegisterClipboardFormat("OwnerLink");
     cfNative    = RegisterClipboardFormat("Native");

     // Create the main window
     hwndMain = CreateWindow(
         szLessonClass,               // class name
         "",                  // title
         WS_OVERLAPPEDWINDOW,         // style
         CW_USEDEFAULT,               // position: default
         CW_USEDEFAULT,
         CW_USEDEFAULT,               // size: default
         CW_USEDEFAULT,
         NULL,                        // parent: none
         NULL,                        // menu: use the class menu
         hInstance,
         NULL
     );

     if (!hwndMain)
         return (FALSE);

     // This document is Untitled
     SetNullFilename (hwndMain);

     ShowWindow(hwndMain, nCmdShow);
     return (TRUE);
 }

 //---------------------------------------------------------------------------
 // TermInstance
 // Purpose:
 // Return: void
 //---------------------------------------------------------------------------
 void TermInstance (void)
 {
 }

 //---------------------------------------------------------------------------
 // MainWndProc
 // Purpose: Handle the main window's events
 //---------------------------------------------------------------------------
 long FAR PASCAL
 MainWndProc(HWND hwnd, unsigned message, WORD wParam, LONG lParam)
 {
     PITEM           pitem;
     HANDLE          hitem;
     PAINTSTRUCT     ps;
     ECDCLIPFORMAT   cfFormat;
    FARPROC lpInsProc;
    RECT rc;
   HDC hDC;
   short mm;
   static BOOL object = 0;
    FARPROC lpProc;
   ECDSTATUS EcdStat;
   HWND hwndItem;


     switch (message)
         {
         case WM_PAINT:
         BeginPaint(hwnd, &ps);
 //        CallWindowProc( lpEditWndProc, hwndEdit, message, ps.hdc, 0L);

             EndPaint (hwnd, &ps);
         break;

       case WM_CREATE:  GetClientRect(hwnd, (LPRECT)&rc);
                         break;


       case WM_COMMAND:
             switch (wParam)
                 {
                 case IDM_COPY:
                 case IDM_CUT:
                     PutOnClipboard(hwnd, wParam);
                     if (wParam == IDM_COPY)
                         break;
               else{
                 HWND hwndChild;
                 PITEM pitem;
                 HANDLE hitem;

                 hwndChild = GetTopChild();

                 hitem = GetWindowWord(hwndChild, 0);
                 pitem = (PITEM)LocalLock(hitem);
                 EcdDelete(pitem->lpecdobject);
                 LocalUnlock(hwndChild);
                 DestroyWindow(hwndChild);
                 break;
                 }

                 case IDM_CLEAR:
                     {
                   HWND hwndChild;
             PITEM pitem, pObjectUndo;
             HANDLE hitem;
             hwndChild = GetTopChild();


                   hitem = GetWindowWord(hwndChild, 0);
                   pitem = (PITEM) LocalLock(hitem);
             PrepareUndoClear(pitem);
             LocalUnlock(hitem);
                   DestroyWindow(hwndChild);
                   fDirty = TRUE;
                   break;
                     }

                 case IDM_PASTE:
                 case IDM_LINK:
                     GetFromClipboard(hwnd, wParam);
               RemoveObjUndo();
                     fDirty = TRUE;
                     break;

                 case IDM_PROPERTIES:
                     {
                     HWND    hwndTop;
                     HANDLE  hitem;
                     PITEM   pitem;

                 hwndTop = GetTopChild();


                     hitem = GetWindowWord(hwndTop, 0);
                     pitem = (PITEM) LocalLock(hitem);

                     lpProc = MakeProcInstance(PropertiesDlgProc, hInst);
                     DialogBox(hInst,
                         (pitem->wType == IDM_LINK) ? "LinkProp" : "EmbProp",
                         hwnd, lpProc);
                     FreeProcInstance(lpProc);
                     LocalUnlock(hitem);
                     break;
                     }

                 case IDM_ABOUT:
                     {
                     FARPROC lpProc;
                     HANDLE  hInst;

                     hInst = GetWindowWord(hwnd, GWW_HINSTANCE);
                     lpProc = MakeProcInstance(AboutDlgProc, hInst);
                     DialogBox(hInst, "AboutBox", hwnd, lpProc);
                     FreeProcInstance(lpProc);
                     break;
                     }

                 case IDM_NEW:
                     New(hwnd);
             RemoveObjUndo();
                     break;
            case IDM_INSERTFILE:
             {
             int fh;

                   fh = Insert(hwndMain);
                   if (fh < 0){
                 MessageBox(hwndMain,
                           "Error In Insert File",
                           szAppName, MB_ICONASTERISK | MB_OK);
                 return FALSE;
                 }
                    //Fall through
               }

            case IDM_UNDO:
            case IDM_COPYLINK:
            case IDM_INSERT:
            case IDM_SHAPES:
            case IDM_PBRUSH:
            case IDM_EXCEL:
            case IDM_GRAPH:
            case IDM_TORUS:

             {
             PITEM pitem;
                // Allocate memory for a new item
                hitem = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITE

                if (hitem == NULL || ((pitem = (PITEM)LocalLock (hitem)) == NU
                    goto errRtn;
                 }

                if (hwndItem = CreateItemWindow(hwndMain, FALSE, NULL))
                    {
                    SetWindowWord (hwndItem, 0, hitem);
                    BringWindowToTop (hwndItem);
                    }
               else
                    goto errRtn;

             rgchChildWnd[irgchChild++] = hwndItem;
                   SetWindowWord (hwndMain, 0, (GetWindowWord(hwndMain, 0)+1)
               if ((wParam == IDM_UNDO) && hObjectUndo){
                 GetUndo(pitem);
                 goto Horrible; //dirtiest code
               }
               else
                 RemoveObjUndo(); // so nothing left of old object

               if (wParam == IDM_INSERTFILE)
                EcdStat = EcdCreateFromTemplate(PROTOCOL, lpclient, (LPSTR)rgc
                  ecdrender_draw, 0);
               else if (wParam == IDM_COPYLINK){
                 EcdStat = CopyLink(pitem);
                 }
               else
                 EcdStat = CreateObject(wParam, pitem);
               if (EcdStat == ECD_WAIT_FOR_RELEASE){
                 WaitForRelease(pitem);
                     }
               if (fTestEcdStat(EcdStat)){
                 MessageBox(hwndMain,
                           "Error In EcdCreate",
                           szAppName, MB_ICONASTERISK | MB_OK);
                 goto errRtn;
                 }
               else {
                     cfFormat = EcdEnumObjectFormats (pitem->lpecdobject, NULL
                    if (cfFormat == cfNative)
                          pitem->wType = IDM_PASTE;
                      else if (cfFormat == cfLink)
                          pitem->wType = IDM_LINK;

                    pitem->wUpdate = IDD_AUTO;
 Horrible:
                   pitem->fOpen = FALSE;
                   pitem->fClose = FALSE;

                    hDC = GetDC(hwndItem);
                   //     EcdSetHostNames(pitem->lpecdobject, szHostname, szHo
                   mm = SetMapMode(hDC, MM_HIMETRIC);
                   EcdQueryBounds(pitem->lpecdobject, &rc);
                   LPtoDP(hDC, (LPPOINT)&rc, 2);
                   SetMapMode(hDC, mm);
                   fInsUpdate = TRUE;
                   if ((rc.right - rc.left == 0) || (rc.bottom - rc.top == 0))
                     rc.right = 200;
                     rc.bottom = 200;
                     rc.left = 0;
                     rc.top = 0;
                     }
                   MoveWindow(hwndItem, rc.left, rc.top, rc.right - rc.left,
                     rc.bottom - rc.top, TRUE);
                    SendMessage (hwndItem, WM_USER, 0, 0L);
                    ShowWindow(hwndItem, SW_SHOW);
                     InvalidateRect(hwndItem, NULL, TRUE);
                    ReleaseDC(hwndItem, hDC);

                   }
                     LocalUnlock(hitem);
               break;
               }

                 case IDM_OPEN:
                     Open(hwnd);
               RemoveObjUndo(); // so nothing left of old
                     break;

                 case IDM_SAVE:
                     Save(hwnd);
                     break;

                 case IDM_SAVEAS:
                     SaveAs(hwnd);
                     break;

           case IDM_EQUAL:
               TestEqual();
               break;

                 case IDM_EXIT:
                     SendMessage (hwnd, WM_CLOSE, 0, 0L);
                     return(0L);
                     break;
                 case IDM_CLOSE:
             {
             HWND hwndTop;
             /*
             hwndTop = GetTopWindow(hwndMain);
             if (hwndTop == hwndEdit)
               hwndTop = GetWindow(hwndTop, GW_HWNDNEXT);
             */
             hwndTop = GetTopChild();

             SendMessage (hwndTop, WM_USER+1, 0, 0L);
                   return(0L);
             }
           case IDM_RECONNECT:
             {
             HWND hwndTop;
             hwndTop = GetTopChild();

             SendMessage (hwndTop, WM_USER+2, 0, 0L);
                   break;
             }

           case IDM_PRINT:
             CallPrint();
             break;
             }
             break;

         case WM_CLOSE:
             if (!SaveAsNeeded(hwnd))
                 return(0L);
             break;

         case WM_DESTROY:
       {
       int nObjects;
       HWND hwndT;
       int i = 0;
       MSG msg;

         nObjDestroy = GetWindowWord(hwndMain, 0);
         nObjects = nObjDestroy;
         while (nObjects--){
           hwndT = GetNextWnd(&i);
           DestroyWindow(hwndT);
           }
         while (nObjDestroy){
           GetMessage(&msg, NULL, NULL, NULL);
               TranslateMessage(&msg);
               DispatchMessage(&msg);
               }
             PostQuitMessage (0);
             return(0L);
         }

         case WM_INITMENU:
             ClientUpdateMenu(hwnd, (HMENU) wParam);
             break;

     }
    return (DefWindowProc(hwnd, message, wParam, lParam));

   errRtn:
     if (pitem)
         LocalUnlock (hitem);

     if (hitem)
         LocalFree (hitem);

     if (hwndItem)
         {
         SetWindowWord(hwndItem, 0, NULL);
         DestroyWindow(hwndItem);
         }

 }


 //---------------------------------------------------------------------------
 // ItemWndProc
 // Purpose: Handle Item window's messages
 //---------------------------------------------------------------------------
 long FAR PASCAL
 ItemWndProc (HWND hwnd, unsigned message, WORD wParam, LONG lParam)
 {
     PITEM           pitem;
     HANDLE          hitem;
    HANDLE        hOldwnd = hwnd;
    static POINT ptOld, ptNew;
    static BOOL bCapture = FALSE;
    static RECT rc;
    int xChange, yChange;
    HWND hNext;
    static int xWnd, yWnd;


     switch (message)
         {
       case WM_USER:
       {
             HANDLE hitem;
             PITEM pitem;
         ECDSTATUS EcdStat;
         HANDLE hWinTitle;
         LPSTR pTitle, pTitle1;

             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock (hitem);
         PrintWIndowTitle(pitem ,hwnd);

             LocalUnlock(hitem);
             break;
             }
       case WM_SIZE:
         {
         RECT rc;
         HWND hdc;
         short mm;
         ECDSTATUS EcdStat;

             hitem = GetWindowWord (hwnd, 0);
         if (hitem && (pitem = (PITEM) LocalLock (hitem))){
           if (pitem->fOpen){
             GetClientRect(hwnd, &rc);
                 hdc = GetDC(hwnd);
             mm = SetMapMode(hdc, MM_HIMETRIC);
             DPtoLP(hdc,(LPPOINT)&rc,2);
             EcdSetBounds(pitem->lpecdobject, (LPRECT)&rc);
              SetMapMode(hdc, mm);
              ReleaseDC(hwnd, hdc);
             }
             LocalUnlock(hitem);
           }
           return (DefWindowProc(hwnd, message, wParam, lParam));
         }


         case WM_DESTROY:
       {
         int i = 0;
             hitem = GetWindowWord (hwnd, 0);
             if (hitem)
                 {
                 pitem = (PITEM) LocalLock (hitem);
                 ClientDelete(pitem);
                 LocalUnlock(hitem);
                 LocalFree(hitem);
                 }
           while (hwnd != rgchChildWnd[i])
             i += 1;
           if (i > MaxChildWnd){
             MessageBox(hwndMain, "Wrong Child Id",
                          szAppName, MB_ICONASTERISK | MB_OK);
             return;
             }
           rgchChildWnd[i] = 0;
           nObjDestroy -= 1;
               SetWindowWord (hwndMain, 0, (GetWindowWord(hwndMain, 0) - 1) );
             break;
         }

         case WM_PAINT:
             {
             HDC             hdc;
             PAINTSTRUCT     ps;

             BeginPaint (hwnd, (LPPAINTSTRUCT)&ps);
             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock (hitem);

             if (pitem)
                 ClientPaint(hwnd, ps.hdc, pitem);
             LocalUnlock(hitem);
         hNext = GetWindow(hwnd, GW_HWNDNEXT);
         if (hNext && (hNext != hwndEdit))
           InvalidateRect(hNext, NULL, FALSE);

             EndPaint (hwnd, (LPPAINTSTRUCT)&ps);
             break;
             }


         case WM_LBUTTONDBLCLK:
             {
             HANDLE hitem;
             PITEM pitem;

             // edit the object
             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock (hitem);
             ClientEdit(hwnd, pitem);
             LocalUnlock(hitem);
             break;
             }
         case WM_LBUTTONDOWN:
             BringWindowToTop (hwnd);
         SetCapture(hwnd);
         GetCursorPos((LPPOINT)&ptOld);
         bCapture = TRUE;
         break;

       case WM_LBUTTONUP:
         if (bCapture){
           bCapture = FALSE;
           ReleaseCapture();
           GetCursorPos((LPPOINT)&ptNew);
           xChange = ptNew.x - ptOld.x;
           yChange = ptNew.y - ptOld.y;
           GetWindowRect(hwnd, (LPRECT)&rc);
               ScreenToClient(hwndMain, (LPPOINT) &rc);
               ScreenToClient(hwndMain, ((LPPOINT) &rc)+1);
           MoveWindow( hwnd, rc.left + xChange, rc.top + yChange,
             rc.right - rc.left, rc.bottom - rc.top, TRUE);
           }
         break;
       case WM_USER+1: // Asked by user to close the document
             {
             HANDLE hitem;
         ECDSTATUS EcdStat;
             PITEM pitem;

             // edit the object
             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock (hitem);
         pitem->fOpen = FALSE;
         pitem->fClose = TRUE;
         if ((EcdStat = EcdClose(pitem->lpecdobject)) == ECD_WAIT_FOR_RELEASE)
           WaitForRelease(pitem);
           }
           if (fTestEcdStat(EcdStat)){
             MessageBox(hwnd, "Error In Closing Object",
                szAppName, MB_ICONASTERISK | MB_OK);
             }
             LocalUnlock(hitem);
           return (DefWindowProc(hwnd, message, wParam, lParam));
             }
       case WM_USER+2: // Asked by user to Reconnect
             {
             HANDLE hitem;
         ECDSTATUS EcdStat;
             PITEM pitem;

             // edit the object
             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock (hitem);
         pitem->fOpen = TRUE;
         pitem->fClose = FALSE;
         if ((EcdStat = EcdReconnect(pitem->lpecdobject)) == ECD_WAIT_FOR_RELE
           WaitForRelease(pitem);
           }
           if (fTestEcdStat(EcdStat)){
             MessageBox(hwnd, "Error In Reconnecting Object",
                szAppName, MB_ICONASTERISK | MB_OK);
             }
             LocalUnlock(hitem);
           return (DefWindowProc(hwnd, message, wParam, lParam));
             }


     }
     return (DefWindowProc(hwnd, message, wParam, lParam));
 }


 //---------------------------------------------------------------------------
 // AboutDlgProc
 // Purpose: Handle the About... dialog box events
 //---------------------------------------------------------------------------
 BOOL FAR PASCAL
 AboutDlgProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
 {
     switch (message)
         {
         case WM_COMMAND:
             if (wParam == IDOK
               || wParam == IDCANCEL)
                 {
                 EndDialog(hDlg, TRUE);
                 return (TRUE);
                 }
             break;
         }
     return (FALSE);
 }


 //---------------------------------------------------------------------------
 // SaveAsDlgProc
 // Purpose: Handle the File Save As... dialog box events
 //---------------------------------------------------------------------------
 BOOL FAR PASCAL
 SaveAsDlgProc (HWND hDlg, unsigned message, WORD wParam, LONG lParam)
 {
     switch (message)
         {
         case WM_COMMAND:
             switch (wParam)
                 {
                 case IDOK:
                     GetDlgItemText(hDlg, IDC_EDIT, (LPSTR) rgchFilename, cbFn
                     EndDialog(hDlg, TRUE);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
                 }
             break;

         case WM_INITDIALOG:
             SetDlgItemText(hDlg, IDC_EDIT, (LPSTR)rgchFilename);
             SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, 0,
                 MAKELONG(0, 32767));
             DlgDirList(hDlg, "", 0, IDC_PATH, 0);
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE);
     }
     return FALSE;
 }

 //---------------------------------------------------------------------------
 // OpenDlgProc
 // Purpose: Handle the File Open... dialog box events
 //---------------------------------------------------------------------------
 int FAR PASCAL OpenDlgProc(HWND hDlg, unsigned message, WORD wParam, LONG lPa
 {
     int fh;

     switch (message)
         {
         case WM_COMMAND:
             switch (wParam)
                 {
                 case IDC_LISTBOX:
                     switch (HIWORD(lParam))
                         {
                         case LBN_SELCHANGE:
                             DlgDirSelect(hDlg, rgchOpenName, IDC_LISTBOX);
                             SetDlgItemText(hDlg, IDC_EDIT, rgchOpenName);
                             SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL,
                                 NULL, MAKELONG(0, 32767));
                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                         }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, rgchOpenName, cbFnMax);

                     if (!rgchOpenName[0])
                         {
                         MessageBox(hDlg, szNoFile,
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                         }

                     if ((fh = _lopen(rgchOpenName, OF_READ)) == -1)
                         {
                         MessageBox(hDlg, szInvalidFn,
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                         }
                     EndDialog(hDlg, fh);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, -1);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:
             DlgDirList(hDlg, "", IDC_LISTBOX, IDC_PATH, 0);
             SetDlgItemText(hDlg, IDC_EDIT, szDefOpen);
             SendDlgItemMessage(hDlg, IDC_EDIT, EM_SETSEL, NULL,
                 MAKELONG(0, 32767));
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); // The focus is already set to a control
     }
     return FALSE;
 }



 //---------------------------------------------------------------------------
 // GetFromClipboard
 // Purpose: Paste or Link from the Clipboard
 // Returns: void
 //---------------------------------------------------------------------------
 void GetFromClipboard (HWND hwndMain, WORD w)
 {
     ClientPasteLink(hwndMain, w);
 }

 //---------------------------------------------------------------------------
 // PutOnClipboard
 // Purpose:  Cut or Copy onto the Clipboard
 // Returns: void
 //---------------------------------------------------------------------------
 void PutOnClipboard(HWND hwndMain, WORD w)
 {
     ClientCutCopy(hwndMain, w);
 }

 //---------------------------------------------------------------------------
 // ResetAnchor
 // Purpose: Resets the anchor so that new child windows are created at the
 //          top left of the main window
 // Returns: void
 //---------------------------------------------------------------------------
 void ResetAnchor(PPOINT pptAnchor)
 {
     pptAnchor->x = dxInflate - dxCascade ;
     pptAnchor->y = dyInflate - dyCascade ;
 }

 //---------------------------------------------------------------------------
 // MoveAnchor
 // Purpose: Moves the anchor so that the new child window
 //          1) appear in cascade;
 //          2) doesn't get created past the edge
 // Returns: void
 //---------------------------------------------------------------------------
 void MoveAnchor(PPOINT pptAnchor, PRECT pclientRect, PPOINT pptSize)
 {
     ptAnchor.y += dyCascade;
     if (pptAnchor->y + pptSize->y >= pclientRect->bottom)
         pptAnchor->y = pclientRect->top ;

     ptAnchor.x += dxCascade;
     if (pptAnchor->x + pptSize->x >= pclientRect->right)
         pptAnchor->x  = pclientRect->left ;
 }

 //---------------------------------------------------------------------------
 // SetNullFilename
 // Purpose: This document is untitled...
 // Returns: void
 //---------------------------------------------------------------------------
 void SetNullFilename (HWND hwndMain)
 {
     SetFilename (hwndMain, szUntitled);
 }


 //---------------------------------------------------------------------------
 // SetFilename
 // Purpose: Update window title
 //          Keep a copy of the filename
 // Returns: FALSE if need to cancel the operation, TRUE otherwise
 //---------------------------------------------------------------------------
 void SetFilename (HWND hwnd, char* rgch)
 {
     char rgchTitle[szMsgMax];

     // Keep a copy of the filename handy
     lstrcpy (rgchFilename, rgch);

     // Set up the window title
     wsprintf ((LPSTR) rgchTitle, (LPSTR) szTitle, (LPSTR) rgch);
     SetWindowText(hwnd, rgchTitle);
 }

 //---------------------------------------------------------------------------
 // SaveAsNeeded
 // Purpose: If necessary, ask the user if s/he wants to save the file
 // Returns: FALSE if need to cancel the operation, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL SaveAsNeeded(HWND hwnd)
 {
     int retval;
     char rgch[szMsgMax];

     if (!fDirty)
         return TRUE;
     wsprintf ((LPSTR) rgch, (LPSTR) szSave, (LPSTR) rgchFilename);
     retval = MessageBox (hwnd, rgch, szAppName,
         MB_YESNOCANCEL | MB_ICONINFORMATION);
     switch (retval)
         {
         case IDNO:
             return TRUE;
         case IDYES:
             return (Save(hwnd));
         default:
             return FALSE;
         }
 }

 //---------------------------------------------------------------------------
 // New
 // Purpose: Delete old Data
 // Returns: FALSE if the operation was canceled, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL New (HWND hwnd)
 {
     // Save the current file if necessary
     if (!SaveAsNeeded(hwnd))
         return (FALSE);

     // delete current objects
     CleanHwnd (hwnd);

     fDirty = FALSE;

     // reset filename
     SetNullFilename(hwnd);
 }

 //---------------------------------------------------------------------------
 // Open
 // Purpose: Ask for a file name
 //          Open the file
 // Returns: FALSE if the operation was canceled, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL Open (HWND hwnd)
 {
     FARPROC lpProc;
     int     fh;

     // Save the current file if necessary
     if (!SaveAsNeeded(hwnd))
         return (FALSE);

     // Ask for a file name
     lpProc = MakeProcInstance(OpenDlgProc, hInst);
     fh = DialogBox(hInst, "Open", hwnd, lpProc);
     FreeProcInstance(lpProc);
     if (fh < 0)
         return (FALSE);
     SetFile(fh);
     lstrcpy(rgchFilename, rgchOpenName);
     SetFilename(hwnd, rgchFilename);

     // delete current objects
     CleanHwnd (hwnd);

     // read new objects
     return(ReadFromFile(hwnd, fh));
 }


 //---------------------------------------------------------------------------
 // Save
 // Purpose: Save the current data to a file
 //          Ask for a new name if necessary
 // Returns: FALSE if the operation was canceled, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL Save(HWND hwnd)
 {
     if (!fDirty)
         {
         // The file is already saved.  We are done.
         return (TRUE);
         }
     if (!lstrcmp((LPSTR) rgchFilename, (LPSTR) szUntitled))
         return (SaveAs(hwnd));
     return (WriteToFile(hwnd));
 }


 //---------------------------------------------------------------------------
 // SaveAs
 // Purpose: Save the current data to a file
 //          Ask for a new name
 // Returns: FALSE if the operation was canceled, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL SaveAs(HWND hwnd)
 {
     FARPROC lpProc;
     int     dlg;

     lpProc = MakeProcInstance(SaveAsDlgProc, hInst);
     dlg = DialogBox(hInst, "SaveAs", hwnd, lpProc);
     FreeProcInstance(lpProc);
     if (!dlg)
         return (FALSE);
     SetFilename(hwnd, rgchFilename);
     return(WriteToFile(hwnd));
 }


 //---------------------------------------------------------------------------
 // WriteToFile
 // Purpose: Write the current data into a file
 // Returns: FALSE if the operation was aborted, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL    WriteToFile (HWND hwndMain)
 {
     int     fh, nObjects;
     HANDLE  hitem;
     PITEM   pitem;
     HWND    hwnd;
   int i =0;
     RECT    rc;

   WORD  wFile, wSize = 0;
   LPSTR lpEditBuffer;
         ECDSTATUS EcdStat;



         if ((fh =_lcreat (rgchFilename, 0)) <= 0)
             {
             MessageBox (
                     GetFocus(),
                     szInvalidFn,
                     szAppName,
                     MB_ICONEXCLAMATION | MB_OK);
             return FALSE;
             }
         SetFile(fh);

       nObjects = GetWindowWord(hwndMain, 0);
       if (_lwrite (fh, (LPSTR)&nObjects, 2) <= 0){
         MessageBox (
                     GetFocus(),
                     szFnError,
                     szAppName,
                     MB_ICONEXCLAMATION | MB_OK);
             _lclose(fh);
             return(FALSE);
             }


         hwnd = GetNextWnd(&i);

     while (hwnd && nObjects--){
       if (hwnd != hwndEdit){
         if (IsIconic(hwnd)){
           rc.left = 0;
           rc.right = 0;
           rc.top = 0;
           rc.bottom = 0;
           }
         else { // if normal size window
           GetWindowRect(hwnd, &rc);
           // Screen coordinates => Parent coordinates
               ScreenToClient(hwndMain, (LPPOINT) &rc);
               ScreenToClient(hwndMain, ((LPPOINT) &rc)+1);
               }
             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock(hitem);
             if ( (_lwrite (fh, (LPSTR) &rc, sizeof(RECT)) <= 0)
                 || (_lwrite (fh, (LPSTR) &(pitem->wType), sizeof(WORD)) <= 0)
                 || (_lwrite (fh, (LPSTR) &(pitem->wUpdate), sizeof(WORD)) <=
                 || ((EcdStat = EcdSaveToStream(((PITEM) pitem)->lpecdobject,
                         (LPECDSTREAM) lpstream)) != ECD_OK))
                {

           if (EcdStat == ECD_WAIT_FOR_RELEASE)
             WaitForRelease(pitem);
           if (fTestEcdStat(EcdStat)){
                   MessageBox (
                         GetFocus(),
                         szFnError,
                         szAppName,
                         MB_ICONEXCLAMATION | MB_OK);
                   LocalUnlock(hitem);
                   _lclose(fh);
                   return(FALSE);
             }
                }
             LocalUnlock(hitem);
             }

         hwnd = GetNextWnd(&i);
     }
     _lclose (fh);
     fDirty = FALSE;
     return TRUE;
 }

 //---------------------------------------------------------------------------
 // ReadFromFile
 // Purpose: Read new data from a file
 // Returns: FALSE if the operation was aborted, TRUE otherwise
 //---------------------------------------------------------------------------
 BOOL ReadFromFile (HWND hwnd, int fh)
 {
     char ch;
     RECT rc;
     BOOL fRet = TRUE;
     LPECDOBJECT lpobject;
     WORD wType, wUpdate;
    WORD wSize;
    LPSTR lpEditBuffer;
    int nObjects;
         ECDSTATUS EcdStat;

         if (_lread (fh, (LPSTR)&nObjects, 2) <= 0)
            return FALSE; // end of file
       SetWindowWord(hwndMain, 0, nObjects);


       while(nObjects--){
         if ((_lread (fh, (LPSTR)&rc, sizeof(RECT)) <= 0)
             || (_lread (fh, (LPSTR) &wType, sizeof(WORD)) <= 0)
                 || (_lread (fh, (LPSTR) &wUpdate, sizeof(WORD)) <= 0)
                 || ((EcdStat = EcdLoadFromStream((LPECDSTREAM) lpstream, PROT
                     lpclient, 0, NULL, &lpobject)) != ECD_OK))
                 {
                 // file problem while reading an object description
             while(EcdQueryReleaseStatus(lpobject) == ECD_BUSY)
               {
               MSG msg;
               GetMessage(&msg, NULL, NULL, NULL);
                 TranslateMessage(&msg);
                 DispatchMessage(&msg);
                }
             if (fEcdReleaseError){
                       MessageBox (
                         GetFocus(),
                         szFnError,
                         szAppName,
                         MB_ICONEXCLAMATION | MB_OK);
                 PrintError(fEcdReleaseStat);
                       fRet = FALSE;
                       break;
                 }
                 }

             ClientCreateNewItem (hwnd, TRUE, &rc, lpobject, wType, wUpdate);
         }

     _lclose (fh);
     return (fRet);
 }


 //---------------------------------------------------------------------------
 // CleanHwnd
 // Purpose: Delete all the children of the main window
 // Returns: void
 //---------------------------------------------------------------------------
 void CleanHwnd (HWND hwndMain)
 {
     HWND hwnd, hwndT;
     HANDLE hitem;
   int nObjects = GetWindowWord(hwndMain, 0);
   int i = 0;

     hwnd = GetWindow (hwndMain, GW_CHILD);

     while (nObjects--){
         hwndT = GetNextWnd(&i);
     if (hwndT != hwndEdit)
         {
         DestroyWindow(hwndT);
         }
     }
     ResetAnchor(&ptAnchor);
 }


 long far PASCAL EditWndProc(HWND hwnd, unsigned message, WORD wParam, LONG lP
 {
   PAINTSTRUCT ps;
   PITEM           pitem;
    HANDLE          hitem;
   POINT pt;
   HWND hNext;


   switch (message) {

   case WM_PAINT:

         BeginPaint(hwnd, &ps);
         CallWindowProc( lpEditWndProc, hwndEdit, message, ps.hdc, 0L);
         hNext = GetWindow(hwnd, GW_HWNDNEXT);
         if (hNext)
           InvalidateRect(hNext, NULL, FALSE);

             EndPaint (hwnd, &ps);
         break;

   default:
       return CallWindowProc(lpEditWndProc, hwndEdit, message, wParam, lParam)
           break;
   }
     return(0L);
 }


 //*------------------------------------------------------------------------
 //| InsFileProc
 //|     Parameters:
 //|         hWnd    - Handle to Window which message is delivered to.
 //|         msgID   - ID number of message
 //|         wParam  - 16-bit parameter
 //|         lParam  - 32-bit parameter
 //|
 //*------------------------------------------------------------------------
 BOOL FAR PASCAL InsFileProc (HWND     hWnd,
                             unsigned wMsgID,
                             WORD     wParam,
                             LONG     lParam)
 {
   int nRet;

     switch(wMsgID)
     {
     case WM_INITDIALOG:
         return TRUE;
     case WM_COMMAND:
         switch (wParam)
         {
         case IDOK:
             nRet = GetDlgItemText(hWnd, 101, (LPSTR)szInsFileName, cbFnMax);
             EndDialog(hWnd,TRUE);
             return TRUE;

         case IDCANCEL:
             EndDialog(hWnd,FALSE);
             return TRUE;
         }
         break;
     }
     return FALSE;
 }

 ECDSTATUS CreateObject(WORD wParam, PITEM pitem)
     {
     char szClassName[szMaxClassName];
     switch(wParam){
       case IDM_SHAPES:
         lstrcpy ((LPSTR)szClassName, "Shapes");
         break;
       case IDM_PBRUSH:
          lstrcpy ((LPSTR)szClassName, "PBrush");
         break;
       case IDM_EXCEL :
         lstrcpy ((LPSTR)szClassName, "ExcelWorksheet");
         break;
       case IDM_GRAPH :
         lstrcpy ((LPSTR)szClassName, "Graph");
         break;
       case IDM_TORUS :
         lstrcpy ((LPSTR)szClassName, "Torus");
         break;
         }
      return(EcdCreate(PROTOCOL, lpclient, (LPSTR)szClassName, 0, NULL, &(pite
           ecdrender_draw,  0));

     }



   void CallPrint(){
     static char szPrinter[80];
     char *szDevice, *szDriver, *szOutput;
     HWND hPrnDC, hDC;
     int nObjects;
      HANDLE  hitem;
      PITEM   pitem;
      HWND    hwnd;
      RECT    rc;
     short mm;
     int nRecSize, nRet;
       HSTR hstr;
       LPSTR lpstrInfo;
     int i =0;




     nObjects = GetWindowWord(hwndMain, 0);
     GetProfileString("windows", "device", ",,", szPrinter, 80);
     if ((szDevice = strtok(szPrinter, ",")) &&
       (szDriver = strtok(NULL, ",")) &&
       (szOutput = strtok(NULL, ",")))
       hPrnDC = CreateIC(szDriver, szDevice, szOutput, NULL);
     else {
          MessageBox (GetFocus(), "Not Printed",
                         szAppName, MB_ICONEXCLAMATION | MB_OK);
                 return;
                 }

     nObjects = GetWindowWord(hwndMain, 0);
     hwnd = GetWindow (hwndMain, GW_CHILD);
     while (hwnd && nObjects--){
       if (hwnd != hwndEdit){
         GetWindowRect(hwnd, &rc);
             // Screen coordinates => Parent coordinates
             ScreenToClient(hwnd, (LPPOINT) &rc);
             ScreenToClient(hwnd, ((LPPOINT) &rc)+1);
         mm = SetMapMode(hPrnDC, MM_ISOTROPIC);
         LPtoDP(hPrnDC, (LPPOINT)&rc, 2);

             hitem = GetWindowWord (hwnd, 0);
             pitem = (PITEM) LocalLock(hitem);
         if (EcdDraw( pitem->lpecdobject, hPrnDC, (LPRECT)&rc, NULL) != ECD_OK
                 {
                 MessageBox (
                         GetFocus(),
                         szFnError,
                         szAppName,
                         MB_ICONEXCLAMATION | MB_OK);
                 LocalUnlock(hitem);
                 return;
                 }
         else {
               LocalUnlock(hitem);
           nRecSize = (rc.right-rc.left)*(rc.top - rc.bottom);
           if (nRecSize < 0)
             nRecSize = - nRecSize;
             nRet = Escape(hPrnDC, STARTDOC, 5, "HELLO",   NULL);
             nRet = Escape(hPrnDC, NEWFRAME, 0, NULL,  NULL);
             nRet = Escape(hPrnDC, ENDDOC, 0, NULL,  NULL);
         SetMapMode(hPrnDC, mm);

             }
       }
         hwnd = GetNextWnd(&i);
       }
     DeleteDC(hPrnDC);
     }


 void RemoveObjUndo(){

       PITEM pitem;
       if (hObjectUndo){
         pitem = (PITEM)LocalLock(hObjectUndo);
         EcdDelete(pitem->lpecdobject);
         LocalUnlock(hObjectUndo);
           LocalFree(hObjectUndo);
           hObjectUndo = NULL;
       }
     }

 void PrintError(ECDSTATUS stat){
   char szError[szMsgMax];

   switch(stat){
     case ECD_ERROR_MEMORY:
       lstrcpy(szError, "Error ECD_ERROR_MEMORY");
       break;
     case ECD_ERROR_FATAL:
       lstrcpy(szError, "Error ECD_ERROR_FATAL");
       break;
     case ECD_ERROR_STREAM:
       lstrcpy(szError, "Error ECD_ERROR_STREAM");
       break;
     case ECD_ERROR_STATIC:
       lstrcpy(szError, "Error ECD_ERROR_STATIC");
       break;
     case ECD_ERROR_BLANK:
       lstrcpy(szError, "Error ECD_ERROR_BLANK");
       break;
     case ECD_ERROR_LAUNCH:
       lstrcpy(szError, "Error ECD_ERROR_LAUNCH");
       break;
     case ECD_ERROR_COMM:
       lstrcpy(szError, "Error ECD_ERROR_COMM");
       break;
     case ECD_ERROR_DRAW:
       lstrcpy(szError, "Error ECD_ERROR_DRAW");
       break;
     case ECD_ERROR_CLIP:
       lstrcpy(szError, "Error ECD_ERROR_CLIP");
       break;
     case ECD_ERROR_FORMAT:
       lstrcpy(szError, "Error ECD_ERROR_FORMAT");
       break;
     case ECD_ERROR_ILLEGALOBJECT:
       lstrcpy(szError, "Error ECD_ERROR_ILLEGALOBJECT");
       break;
     case ECD_ERROR_OPTION:
       lstrcpy(szError, "Error ECD_ERROR_OPTION");
       break;
     case ECD_ERROR_PROTOCOL:
       lstrcpy(szError, "Error ECD_ERROR_PROTOC");
       break;
     case ECD_ERROR_ADDRESS:
       lstrcpy(szError, "Error ECD_ERROR_ADDRESS");
       break;

     case ECD_ERROR_NOT_EQUAL:
       lstrcpy(szError, "Error ECD_ERROR_NOT_EQUAL");
       break;

     case ECD_ERROR_HANDLE:
       lstrcpy(szError, "Error ECD_ERROR_HANDLE");
       break;
     case ECD_ERROR_GENERIC:
       lstrcpy(szError, "Error ECD_ERROR_GENERIC");
       break;
     case ECD_WAIT_FOR_RELEASE:
       lstrcpy(szError, "Error ECD_WAIT_FOR_RELEASE");
       break;
     case ECD_ERROR_MAPPING_MODE:
       lstrcpy(szError, "Error ECD_ERROR_MAPPING_MODE");
       break;

     case ECD_ERROR_INVALIDCLASS:
       lstrcpy(szError, "Error ECD_ERROR_INVALIDCLASS");
       break;
     case ECD_ERROR_SYNTAX:
       lstrcpy(szError, "Error ECD_ERROR_SYNTAX");
       break;
     case ECD_ERROR_NOT_OPEN:
       lstrcpy(szError, "Error ECD_ERROR_NOTOPEN");
       break;
     case ECD_ERROR_PROTECT_ONLY:
       lstrcpy(szError, "Error ECD_ERROR_PROTECT_ONLY");
       break;
     case ECD_ERROR_POKENATIVE:
       lstrcpy(szError, "Error ECD_ERROR_POKENATIVE");
       break;
     case ECD_ERROR_ADVISE_PICT:
       lstrcpy(szError, "Error ECD_ERROR_ADVISE_PICT");
       break;
     case ECD_ERROR_DATATYPE:
       lstrcpy(szError, "Error ECD_ERROR_DATATYPE");
       break;
     case ECD_ERROR_ALREADY_BLOCKED:
       lstrcpy(szError, "Error ECD_ERROR_ALREADYBLOCKED");
       break;
     default:
       lstrcpy(szError, "Error Other");
       break;
       }

       MessageBox(hwndMain,szError, szAppName, MB_ICONASTERISK | MB_OK);
       }




 void PrintWindowTitle(PITEM pitem, HWND hwnd){

   ECDSTATUS EcdStat;
   HANDLE hWinTitle;
     LPSTR pTitle, pTitle1;
    LPSTR lpstrInfo, lpstr1, lpstr2;
   HSTR hstr;

             if (((EcdStat = EcdGetData(pitem->lpecdobject,
                     (pitem->wType == IDM_PASTE) ? cfOwnerLink : cfLink,
                     &hstr))
                     == ECD_OK)
                 && hstr)
                 {
                 // Both link formats are:  "szClass szDocument szItem 0"
                 lpstrInfo = GlobalLock(hstr);
            lpstr1 = lpstrInfo;
            hWinTitle = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, 512);
            pTitle = pTitle1 = (LPSTR)LocalLock(hWinTitle);
           if (pitem->wType == IDM_PASTE){
             lstrcpy(pTitle, "Embed!");
             pTitle += 6;
             }
           else{
             lstrcat(pTitle, "Link!");
             pTitle += 5;
             }
            while (*lpstr1){
             *(pTitle++) = *(lpstr1++);
             }
            *(pTitle++) = '!';
            lpstr1 += 1;
            while (*lpstr1)
             *(pTitle++) = *(lpstr1++);
            *(pTitle++) = '!';
            lpstr1 += 1;
            while (*lpstr1)
             *(pTitle++) = *(lpstr1++);
            *pTitle = '!';
            lpstr1 += 1;


                 SetWindowText(hwnd, (LPSTR)pTitle1);
            LocalUnlock(hWinTitle);
           LocalFree(hWinTitle);
                GlobalUnlock(hstr);
                 }
           }

 void GetUndo(PITEM pitem){
   PITEM pObjectUndo;

   pObjectUndo = (PITEM)LocalLock(hObjectUndo);
   pitem->wType = pObjectUndo->wType ;
   pitem->wUpdate = pObjectUndo->wUpdate ;
   pitem->lpecdobject = pObjectUndo->lpecdobject;
   LocalUnlock(hObjectUndo);
   LocalFree(hObjectUndo);
   hObjectUndo = 0;
   }

 ECDSTATUS CopyLink(PITEM pCopy){
    HWND hwnd;
     HANDLE hitem;
     PITEM pitem;
   ECDSTATUS EcdStat;
   int i = 0;

   hwnd = GetNextWnd(&i);
    hitem = GetWindowWord(hwnd, 0);
    pitem = (PITEM) LocalLock(hitem);
   EcdStat = EcdCopyFromLink(pitem->lpecdobject, PROTOCOL, lpclient,NULL, NULL
   LocalUnlock(hitem);
   return EcdStat;
 }

 VOID WaitForRelease(PITEM pitem){
    MSG msg;

   fEcdrelease = FALSE;
   do  {
   GetMessage(&msg, NULL, NULL, NULL);
    TranslateMessage(&msg);
    DispatchMessage(&msg);
    }
 while (!fEcdrelease);
 }


 HWND GetTopChild(){
   HWND  hwnd;
   int i = 0;

   hwnd = GetTopWindow(hwndMain);

   while ((hwnd != rgchChildWnd[i]) && i++ < irgchChild)
     ;
   if (i <= irgchChild) // if it was found
     return hwnd;
   // else find the first non null guy
   i = 0;
   while (!(hwnd = rgchChildWnd[i]) && i++ < irgchChild)
     ;
     return hwnd;
 }

 HWND GetNextWnd(LPINT i){
   HWND hwnd;
   while (!(hwnd = rgchChildWnd[*i]) && *i < irgchChild)
     *i += 1;
   *i += 1;
   return hwnd;
 }


 BOOL fTestEcdStat(ECDSTATUS EcdStat){
   // use it for Async conditions

   switch(EcdStat){
     case ECD_WAIT_FOR_RELEASE:
       if (fEcdReleaseError){
         PrintError(fEcdReleaseStat);
         return TRUE;
         }
       else
         return FALSE;
       break;
     case ECD_OK:
       return FALSE;
     default:
       PrintError(EcdStat);
       return TRUE;
       }
     }


 BOOL Insert(HWND hwnd)
 {
     FARPROC lpProc;
     int     fh;


     // Ask for a file name
     lpProc = MakeProcInstance(OpenDlgProc, hInst);
     fh = DialogBox(hInst, "Open", hwnd, lpProc);
     FreeProcInstance(lpProc);
   if (fh > 0)
     _lclose(fh); // because the file is opened in Open
     return (fh);

 }


 VOID TestEqual(){ // test the top and next object are equal
   HWND hTop, hNext;
   HANDLE hitem1, hitem2;
   PITEM pitem1, pitem2;
   ECDSTATUS EcdStat;
   int i = 0;

   hTop = GetTopChild();
   hitem1 = GetWindowWord(hTop, 0);
   pitem1 = (PITEM)LocalLock(hitem1);

   hNext = GetNextWnd(&i);
   hitem2 = GetWindowWord(hNext, 0);
   pitem2 = (PITEM)LocalLock(hitem2);

   EcdStat = EcdEqual(pitem1->lpecdobject, pitem2->lpecdobject);
   if (EcdStat == ECD_WAIT_FOR_RELEASE)
     WaitForRelease(pitem1);
   if (fTestEcdStat(EcdStat))
     PrintError(EcdStat);
 }






 CLIENT.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\CLIENT\CLIENT.C

 //---------------------------------------------------------------------------
 // client.c
 //
 // Copyright (c) Microsoft Corporation, 1990-
 //---------------------------------------------------------------------------

 #include "windows.h"
 #include "ecd.h"
 #include "cldemo.h"
 #include "client.h"

 //--- Globals --------------------------------------------------------------
 extern HWND  hwndEdit;
 extern BOOL fInsUpdate;
 extern HWND rgchChildWnd[];
 extern int irgchChild;
 // extern BOOL fObjectClose;

 LPECDCLIENT     lpclient;
 ECDCLIENTVTBL   clientTbl;
 ECDSTREAMVTBL   streamTbl;
 LPAPPSTREAM     lpstream;
 HANDLE      hObjectUndo = NULL;
 LPECDOBJECT     lpObjectUndo;
 WORD            wUpdateUndo, wTypeUndo;
 BOOL            fEcdrelease;
 BOOL            fEcdReleaseError;
 BOOL            fEcdReleaseStat;
 HANDLE          hobjStream = NULL;
 HANDLE          hobjClient = NULL;
 // HANDLE       hobjPrn = NULL;
 HANDLE hWinTitle = 0;
 int  nOffDocNm, nOffItemNm;


 //--- Local Functions Declaration -------------------------------------------
 void GetUpdateStatus(HWND hDlg);
 void PrepareUndo(PITEM pitem);
 void PrepareUndoClear(PITEM pitem);
 void PrintWindowTitle(PITEM pitem, HWND hwnd);
 VOID SetRectSize(HWND hwnd, PITEM pitem);
 void PrintLinkName(PITEM pitem, HWND hwnd);
 void SetData(PITEM pitem, HWND hDlg);


 extern HWND GetTopChild();
 extern HWND GetNextWnd(LPINT i);

 //---------------------------------------------------------------------------
 // InitClient
 // Purpose: Set up this application as a client
 // Returns: TRUE if successful
 //---------------------------------------------------------------------------
 BOOL InitClient (HANDLE hInstance)
     {

     // Set up the client structure

     if (!(hobjClient = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
                                    sizeof(ECDCLIENT))))
             return FALSE;

     if (!(lpclient = (LPECDCLIENT)(GlobalLock(hobjClient))))
         {
         GlobalFree(hobjClient);
         hobjClient = NULL;
         return FALSE;
         }

     lpclient->lpvtbl = (LPECDCLIENTVTBL)&clientTbl;

     lpclient->lpvtbl->CallBack = MakeProcInstance(CallBack, hInstance);

     // Set up the stream structure

     if (!(hobjStream = GlobalAlloc (GMEM_MOVEABLE, sizeof(APPSTREAM))))
         {
         GlobalUnlock(hobjClient);
         GlobalFree(hobjClient);
         hobjClient = NULL;
         return FALSE;
         }

     if(lpstream = (LPAPPSTREAM)(GlobalLock(hobjStream)))
         {
         lpstream->lpstbl = (LPECDSTREAMVTBL)&streamTbl;
         streamTbl.Get =
             (LONG  (pascal far *) (LPECDSTREAM, LPSTR, LONG))
             MakeProcInstance((FARPROC) ReadStream, hInstance);
         streamTbl.Put =
             (LONG  (pascal far *) (LPECDSTREAM, LPSTR, LONG))
             MakeProcInstance((FARPROC) WriteStream, hInstance);
         streamTbl.Seek =
             (LONG  (pascal far *) (LPECDSTREAM, LONG))
             MakeProcInstance((FARPROC) PosStream, hInstance);
         streamTbl.Status =  MakeProcInstance((FARPROC) StatusStream, hInstanc
         lpstream->hobjStream = hobjStream;
         }
     else
         {
         GlobalUnlock(hobjClient);
         GlobalFree(hobjClient);
         hobjClient = NULL;
         GlobalFree(hobjStream);
         hobjStream = NULL;
         return FALSE;
         }
     return TRUE;
 }

 //---------------------------------------------------------------------------
 // TermClient
 // Purpose: To clean up after termination
 // Returns: void
 //---------------------------------------------------------------------------
 void TermClient (void)
 {
     // Get rid of the client structure
     if (hobjClient)
         {
         GlobalUnlock(hobjClient);
         GlobalFree(hobjClient);
         }

     // Get rid of the stream structure
     if (hobjStream)
         {
         GlobalUnlock(hobjStream);
         GlobalFree(hobjStream);
         }
 }

 //---------------------------------------------------------------------------
 // CallBack
 // Purpose: Client Callback Function
 //---------------------------------------------------------------------------
 int FAR PASCAL
 CallBack(LPECDCLIENT lpclient, int flags, LPECDOBJECT lpObject)
 {
   RECT rc;
   HWND hDC;
   ECDSTATUS EcdStat;
     switch(flags)
         {
         case ECD_SAVED:
         case ECD_CHANGED:
         case ECD_CLOSED:
             {
             HANDLE hitem;
             PITEM  pitem;
             HWND   hwnd, hNext;
         short mm;

             // The file needs to be saved
             fDirty = TRUE;

             // Find out if we need to update our visuals immediately
         if (fInsUpdate){ // it is for case when object created by EcdCreate
           fInsUpdate = FALSE;
           }

             hwnd = GetTopWindow(hwndMain);
         while(hwnd){
           if (hwnd != hwndEdit){
             hitem = GetWindowWord(hwnd, 0);
             pitem = (PITEM) LocalLock(hitem);
                 if (pitem->lpecdobject == lpObject && (flags == ECD_CLOSED)){
               pitem->fOpen = FALSE;
               }
                 if (pitem->lpecdobject == lpObject){
               SetRectSize(hwnd, pitem);
                     InvalidateRect(hwnd, NULL, TRUE);
               }
                 LocalUnlock(hitem);
             }
           hwnd = GetWindow(hwnd, GW_HWNDNEXT);
           }

             }
               break;

         case ECD_RELEASE:
             fEcdrelease = TRUE;
         if ((fEcdReleaseStat = EcdQueryReleaseError(lpObject)) != ECD_OK){
           fEcdReleaseError = TRUE;
           }
         else
           fEcdReleaseError = FALSE;

             break;

         case ECD_QUERY_PAINT:
             // Yes, paint!
             return TRUE;
             break;

         case ECD_RENAMED:
             // The file needs to be saved
             fDirty = TRUE;
             break;

         default:
             break;
     }
     return 0;
 }

 //---------------------------------------------------------------------------
 // ClientUpdateMenu
 // Purpose: Update the Edit menu
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientUpdateMenu(HWND hwnd, HMENU hMenu)
 {
     HWND    hwndChild;
     HANDLE  hitem;
     PITEM   pitem;
     int     mfPaste = MF_GRAYED;
     int     mfPasteLink = MF_GRAYED;
     int     mfProperties = MF_GRAYED;
     int     mfClear = MF_GRAYED;
     int     mfCut   = MF_GRAYED;
     int     mfCopy  = MF_GRAYED;
     int     mfUndo  = MF_GRAYED;
     int     mfClose  = MF_GRAYED;
     int     mfCopyLink  = MF_GRAYED;
     int     mfReconnect  = MF_GRAYED;

     // Enable "Paste" if there is a paste-able object in the clipboard */
    if (hObjectUndo)
     mfUndo = MF_ENABLED;
     if (EcdQueryCreateFromClip(PROTOCOL, ecdrender_draw, 0) == ECD_OK)
         mfPaste = MF_ENABLED;

     // Enable "Paste Link" if there is a link-able object in the clipboard
     if (EcdQueryLinkFromClip(PROTOCOL, ecdrender_draw, 0) == ECD_OK)
         mfPasteLink = MF_ENABLED;

     // Enable "Clear", "Cut", "Copy" and maybe "Properties..."
     // if we have a child window
     if (GetWindowWord(hwndMain, 0)) // if there is any window
         {
         mfClear = MF_ENABLED;
         mfCut   = MF_ENABLED;
         mfCopy  = MF_ENABLED;
         mfCopyLink  = MF_ENABLED;
          hwndChild = GetTopWindow(hwnd);
       if (hwndChild == hwndEdit)
       hwndChild = GetTopWindow(hwnd);
         hitem = GetWindowWord(hwndChild, 0);
         pitem = (PITEM) LocalLock(hitem);
         if (pitem->wType != IDM_STATIC)
             mfProperties = MF_ENABLED;
       if (pitem->fOpen)
           mfClose  = MF_ENABLED;
       if (pitem->fClose)
       mfReconnect = MF_ENABLED;
         LocalUnlock(hitem);
         }

     EnableMenuItem(hMenu, IDM_UNDO,       mfUndo);
     EnableMenuItem(hMenu, IDM_CUT,        mfCut);
     EnableMenuItem(hMenu, IDM_COPY,       mfCopy);
     EnableMenuItem(hMenu, IDM_CLOSE,      mfClose);
     EnableMenuItem(hMenu, IDM_COPYLINK,   mfCopyLink);
     EnableMenuItem(hMenu, IDM_LINK,       mfPasteLink);
     EnableMenuItem(hMenu, IDM_PASTE,      mfPaste);
     EnableMenuItem(hMenu, IDM_CLEAR,      mfClear);
     EnableMenuItem(hMenu, IDM_PROPERTIES, mfProperties);
     EnableMenuItem(hMenu, IDM_RECONNECT,  mfReconnect);
 }

 //---------------------------------------------------------------------------
 // ClientCutCopy
 // Purpose: Does "Cut" and "Copy"
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientCutCopy(HWND hwndMain, WORD w)
 {
     HWND hwnd;
     HANDLE hitem;
     PITEM pitem;

     hwnd = GetTopWindow(hwndMain);
     hitem = GetWindowWord(hwnd, 0);
     pitem = (PITEM) LocalLock(hitem);
     if (pitem->lpecdobject && OpenClipboard(hwndMain))
         {
         EmptyClipboard();
         if (w = IDM_COPY)
             {
             EcdCopyToClipboard(pitem->lpecdobject);
             }
         else
             {
             EcdCutToClipboard(pitem->lpecdobject);
             pitem->lpecdobject = NULL;
             }
         CloseClipboard();
         }
     LocalUnlock(hitem);
 }


 //---------------------------------------------------------------------------
 // ClientPasteLink
 // Purpose: Does "Paste" and "Paste Link"
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientPasteLink(HWND hwndMain, WORD w)
 {
     HWND hwnd = NULL;
     HANDLE hitem;
     PITEM pitem = NULL;
     ECDCLIPFORMAT   cfFormat;

   RECT rc;
   HDC hdc;
   short mm;
   POINT pt;
   ECDSTATUS EcdStat;

     // Allocate memory for a new item
     hitem = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITEM));
     if (hitem == NULL || ((pitem = (PITEM)LocalLock (hitem)) == NULL))
         goto  errRtn;

     if (hwnd = CreateItemWindow(hwndMain, FALSE, NULL))
         {
         SetWindowWord (hwnd, 0, hitem);
         BringWindowToTop (hwnd);
         }
     else goto errRtn;

     rgchChildWnd[irgchChild++] = hwnd;
         SetWindowWord (hwndMain, 0, (GetWindowWord(hwndMain, 0)+1) );

     // Grab the item from the clipboard
     switch (w)
         {
         case IDM_PASTE:
             if (!OpenClipboard(hwndMain))
                 goto errRtn;
             else if( (EcdStat = EcdCreateFromClip(PROTOCOL, lpclient, 0, NULL
                 ecdrender_draw,  0)) != ECD_OK)
                 {
           if (EcdStat == ECD_WAIT_FOR_RELEASE)
             WaitForRelease(pitem);
           if (fTestEcdStat(EcdStat)){
              CloseClipboard();
              goto errRtn;
                  }
                 }
             CloseClipboard();
             break;
         case IDM_LINK:
             if (!OpenClipboard(hwndMain))
                 goto errRtn;
             else if ( (EcdStat = EcdCreateLinkFromClip(PROTOCOL, lpclient, 0,
                     ecdrender_draw, 0)) != ECD_OK)
                 {
             if (EcdStat == ECD_WAIT_FOR_RELEASE)
             WaitForRelease(pitem);
           if (fTestEcdStat(EcdStat)){
                CloseClipboard();
                goto errRtn;
                    }
                 }
             CloseClipboard();
             break;
         }

     pitem->fOpen = FALSE;
     pitem->fClose = FALSE;
     cfFormat = EcdEnumObjectFormats (pitem->lpecdobject, NULL);
     if (cfFormat == cfNative)
     {
         pitem->wType = IDM_PASTE;
     }
     else if (cfFormat == cfLink)
         pitem->wType = IDM_LINK;

     pitem->wUpdate = IDD_AUTO;

     EcdSetHostNames(pitem->lpecdobject, szHostname, szHostobjectname);

   GetCaretPos((LPPOINT)&pt);
   pt.y += 15;
   hdc = GetDC(hwnd);
   mm = SetMapMode(hdc, MM_HIMETRIC);
   DPtoLP(hdc, (LPPOINT)&pt, 1);

   EcdQueryBounds(pitem->lpecdobject, &rc);
   rc.top = pt.y ;
   rc.bottom += pt.y ;
   LPtoDP(hdc, (LPPOINT)&rc, 2);


   SetMapMode(hdc, mm);
   MoveWindow(hwnd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top +
     GetSystemMetrics(SM_CYCAPTION), TRUE);
   ReleaseDC(hwnd, hdc);
    SendMessage (hwnd, WM_USER, 0, 0L);

     ShowWindow(hwnd, SW_SHOW);
    InvalidateRect(hwnd, NULL, TRUE);

     LocalUnlock(hitem);

     return;

  errRtn:
     if (pitem)
         LocalUnlock (hitem);

     if (hitem)
         LocalFree (hitem);

     if (hwnd)
         {
         SetWindowWord(hwnd, 0, NULL);
         DestroyWindow(hwnd);
         }

 }

 //---------------------------------------------------------------------------
 // ClientCreateNewItem
 // Purpose: Creates a new window and associates a new item
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientCreateNewItem (HWND hwndMain, BOOL fVisible,
     LPRECT lprect, LPECDOBJECT lpobject, WORD wType, WORD wUpdate)
 {
     HWND   hwndItem;
     HANDLE hitem;
     PITEM  pitem = NULL;
   BOOL fIconic = FALSE;

     // Allocate memory for a new item
     hitem = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITEM));

     if (hitem == NULL || ((pitem = (PITEM)LocalLock (hitem)) == NULL))
         goto  errRtn;

     pitem->wType = wType;
     pitem->wUpdate = wUpdate;
     pitem->lpecdobject = lpobject;

   pitem->fOpen = FALSE;
   pitem->fClose = FALSE;

     // Create a window in which to put the new item
   if ((lprect->left == 0) && (lprect->top == 0) && (lprect->right == 0) && (
     lprect->bottom == 0)) // i.e. iconic window
     fIconic = TRUE;
     if (hwndItem = CreateItemWindow(hwndMain, fIconic, lprect))
         {
       if (!fIconic)
         MoveWindow(hwndItem, lprect->left, lprect->top,
           lprect->right - lprect->left, lprect->bottom - lprect->top, TRUE);
         EcdSetHostNames(pitem->lpecdobject, szHostname, szHostobjectname);
         SetWindowWord (hwndItem, 0, hitem);
       rgchChildWnd[irgchChild++] = hwndItem;
        SendMessage (hwndItem, WM_USER, 0, 0L);
         if (fVisible)
             ShowWindow(hwndItem, SW_SHOW);
         InvalidateRect(hwndItem, NULL, TRUE);
         }
     else goto errRtn;
     LocalUnlock(hitem);
     return;

  errRtn:
     if (pitem)
         LocalUnlock (hitem);

     if (hitem)
         LocalFree (hitem);
 }

 //---------------------------------------------------------------------------
 // ClientPaint
 // Purpose: Ask the server to paint for us
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientPaint(HWND hwnd, HDC hdc, PITEM pitem)
 {
     RECT rc;
   HDC saveDC;
   short mm;
   POINT pt;
   int bot;

     // Find the coordinates of the "display" area


     GetClientRect (hwnd, (LPRECT)&rc);

     // Convert the rectangle's coordinates to MM_HIMETRIC
     SetMapMode(hdc, MM_HIMETRIC);
     DPtoLP(hdc,(LPPOINT)&rc,2);

     // Ask the server to draw the object
     EcdDraw (pitem->lpecdobject, hdc, (LPRECT)&rc, hdc);
 }

 //---------------------------------------------------------------------------
 // ClientEdit
 // Purpose: Ask the server to edit the object
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientEdit(HWND hwnd, PITEM pitem)
 {
     RECT rc;
   HWND hdc;
   short mm;
   ECDSTATUS EcdStat;

     GetClientRect(hwnd,&rc);
    if (EcdQueryOpen(pitem->lpecdobject) != ECD_OK) //
       EcdStat = EcdOpen (pitem->lpecdobject, TRUE, hwnd, &rc);
    else{
       EcdStat = EcdOpen (pitem->lpecdobject, TRUE, hwnd, &rc);
     /* should be following code
     if (EcdReconnect(pitem->lpecdobject) != ECD_OK){
       MessageBox(hwndMain, "Error Reconnecting ",
                           szAppName, MB_ICONASTERISK | MB_OK);
         EcdOpen (pitem->lpecdobject, TRUE, hwnd, &rc);
       }
     */
     }
     pitem->fOpen = TRUE;
     if (EcdStat != ECD_OK){
       if (EcdStat == ECD_WAIT_FOR_RELEASE)
         WaitForRelease(pitem);
         if (fTestEcdStat(EcdStat)){
         }
       }

   hdc = GetDC(hwnd);
     mm = SetMapMode(hdc, MM_HIMETRIC);
     DPtoLP(hdc,(LPPOINT)&rc,2);
   EcdSetBounds(pitem->lpecdobject, (LPRECT)&rc);
   SetMapMode(hdc, mm);
   ReleaseDC(hwnd, hdc);

 }

 //---------------------------------------------------------------------------
 // ClientDelete
 // Purpose: Ask the server to delete the object
 // Returns: void
 //---------------------------------------------------------------------------
 void ClientDelete(PITEM pitem)
 {
     MSG msg;

     if (EcdDelete (pitem->lpecdobject) == ECD_WAIT_FOR_RELEASE)
         {
         fEcdrelease = FALSE;
           do
             {
             GetMessage(&msg, NULL, NULL, NULL);
             TranslateMessage(&msg);
             DispatchMessage(&msg);
             }
         while (!fEcdrelease);
         }
 }

 //---------------------------------------------------------------------------
 // SetFile
 // Purpose: Set up the stream structure
 // Returns: void
 //---------------------------------------------------------------------------
 void SetFile (int fh)
 {
     lpstream->fh = fh;
 }

 //---------------------------------------------------------------------------
 // PropertiesDlgProc
 // Purpose: Handles the Properties... dialog box events
 //---------------------------------------------------------------------------
 BOOL FAR PASCAL
 PropertiesDlgProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
 {
     HWND hwnd;
     HANDLE hitem;
     PITEM pitem;
     LPECDOBJECT lpobject;
     HSTR hstr;
     LPSTR lpstrInfo, lpstr1, lpstr2;

     switch (message)
         {
         case WM_INITDIALOG:
             lpObjectUndo = NULL;
             wUpdateUndo = 0;
         hwnd = GetTopChild();
             hitem = GetWindowWord(hwnd, 0);
             pitem = (PITEM) LocalLock(hitem);
             PrepareUndo(pitem);
             CheckDlgButton(hDlg, pitem->wUpdate, TRUE);
             if (pitem->wType == IDM_PASTE)
                 EnableWindow(GetDlgItem(hDlg, IDCANCEL), FALSE);
           if (pitem->wType != IDM_PASTE)
             PrintLinkName(pitem, hDlg);
          //    PrintWindowTitle(pitem, GetDlgItem(hDlg, IDD_LINKINFO));
           else
              PrintWindowTitle(pitem, GetDlgItem(hDlg, IDD_WHICH));

             LocalUnlock(hitem);
             return (TRUE);

         case WM_COMMAND:
             switch (wParam)
                 {
                 case IDD_FREEZE:
                 case IDD_UPDATE:
             /*
                     hwnd = GetTopWindow(hwndMain);
               if (hwnd == hwndEdit)
                 hwnd = GetWindow(hwnd, GW_HWNDNEXT);
               */
               hwnd = GetTopChild();
                     hitem = GetWindowWord(hwnd,0);
                     pitem = (PITEM) LocalLock(hitem);
                     if (wParam == IDD_FREEZE)
                         {
                         if (pitem->wType == IDM_PASTE)
                             EnableWindow(GetDlgItem(hDlg, IDCANCEL), TRUE);
                         else
                             EnableWindow(GetDlgItem(hDlg, IDD_UPDATE), FALSE)
                         EnableWindow(GetDlgItem(hDlg, IDD_EDIT), FALSE);
                         EnableWindow(GetDlgItem(hDlg, IDD_FREEZE), FALSE);
                         if (EcdObjectConvert(pitem->lpecdobject, SPROTOCOL,
                             lpclient, NULL, NULL, &lpobject) == ECD_OK)
                             {
                             ClientDelete (pitem);
                             pitem->lpecdobject = lpobject;
                             pitem->wType = IDM_STATIC;
                             }
                         }
                     else // (wParam == IDD_UPDATE)
                         {
                         EcdUpdate(pitem->lpecdobject);
                         }
                     fDirty = TRUE;
                     InvalidateRect(hwnd, NULL, TRUE);
                     LocalUnlock(hitem);
                     break;

                 case IDD_EDIT:
                     {
                     RECT rc;

                     GetUpdateStatus(hDlg);
               hwnd = GetTopChild();

                     hitem = GetWindowWord(hwnd, 0);
                     pitem = (PITEM) LocalLock(hitem);
                     EcdDelete(lpObjectUndo);
                   lpObjectUndo = NULL;
                     GetClientRect(hwnd,&rc);
                     EcdOpen (pitem->lpecdobject, TRUE, hwnd, &rc);
                     LocalUnlock(hitem);
                     fDirty = TRUE;
                     InvalidateRect(hwnd, NULL, TRUE);
                     }
                     /* Fall through */

                 case IDOK:
                     GetUpdateStatus(hDlg);
                     EcdDelete(lpObjectUndo);
                   lpObjectUndo = NULL;
               hwnd = GetTopChild();
                   hitem = GetWindowWord(hwnd, 0);
                   pitem = (PITEM) LocalLock(hitem);
               if (pitem->wType != IDM_PASTE)
                 SetData(pitem, hDlg);
               LocalUnlock(hitem);
               GlobalFree(hWinTitle);
                     EndDialog(hDlg, TRUE);
                     return TRUE;

                 case IDCANCEL:
               hwnd = GetTopChild();

                     hitem = GetWindowWord(hwnd, 0);
                     pitem = (PITEM) LocalLock(hitem);
                     if (lpObjectUndo)
                         {
                         EcdDelete(pitem->lpecdobject);
                         pitem->lpecdobject = lpObjectUndo;
                         pitem->wType = wTypeUndo;
                         pitem->wUpdate  = wUpdateUndo;
                         }
                     LocalUnlock(hitem);
             InvalidateRect(hwnd, NULL, TRUE);
               GlobalFree(hWinTitle);
                     EndDialog(hDlg, TRUE);
                     return TRUE;
                 }
             break;
         }
     return (FALSE);
 }


 //---------------------------------------------------------------------------
 // GetUpdateStatus
 // Purpose: Read the status of the update buttons in the Properties Dialog
 //          associate to a linked object.
 //          Updates the internal data structures and inform the dll.
 // Return: void
 //---------------------------------------------------------------------------
 void GetUpdateStatus(HWND hDlg)
 {
     WORD wUpdate;
     HWND hwnd;
     HANDLE hitem;
     PITEM pitem;
    ECDSTATUS EcdRet;
    ECDOPT_UPDATE EcdOpt;


   hwnd = GetTopChild();
     hitem = GetWindowWord(hwnd, 0);
     pitem = (PITEM) LocalLock(hitem);
     if (pitem->wType == IDM_LINK)
         {
         wUpdate = (IsDlgButtonChecked(hDlg, IDD_AUTO) ?
             IDD_AUTO : IDD_MANUAL);
         if (wUpdate != pitem->wUpdate)
             {
             pitem->wUpdate = wUpdate;
         EcdRet = EcdGetLinkUpdateOptions(pitem->lpecdobject,
           (ECDOPT_UPDATE FAR *)&EcdOpt);
         if ((wUpdate == IDD_AUTO )&& (EcdOpt != ecdupdate_always))
           EcdSetLinkUpdateOptions(pitem->lpecdobject, ecdupdate_always);
         else if ((wUpdate == IDD_MANUAL) && (EcdOpt != ecdupdate_oncall))
           EcdSetLinkUpdateOptions(pitem->lpecdobject, ecdupdate_oncall);
             }
         }
     LocalUnlock(hitem);
 }

 //---------------------------------------------------------------------------
 // PrepareUndo
 // Purpose: Keep track of the current object to be able to Undo later
 // Return: void
 //---------------------------------------------------------------------------
 void PrepareUndo(PITEM pitem)
 {
     // Delete the old copy of the object if necessary
     if (lpObjectUndo)
         EcdDelete(lpObjectUndo);

     // Create a copy of the current object
     if (EcdClone(pitem->lpecdobject, lpclient,
         NULL, NULL, (LPECDOBJECT FAR *)&lpObjectUndo) != ECD_OK)
         lpObjectUndo = NULL;
     else
         {
         wUpdateUndo = pitem->wUpdate;
         wTypeUndo = pitem->wType;
         }
 }


 //---------------------------------------------------------------------------
 // PrepareUndoClear
 // Purpose: Keep track of the current object to be able to Undo later
 // Return: void
 //---------------------------------------------------------------------------
 void PrepareUndoClear(PITEM pitem)
 {
   PITEM pObjectUndo;
     // Delete the old copy of the object if necessary
     if (hObjectUndo){
     pObjectUndo = (PITEM)LocalLock(hObjectUndo);
     EcdDelete(pObjectUndo->lpecdobject);
     }
   else {
     hObjectUndo = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITEM));
     pObjectUndo = (PITEM) LocalLock(hObjectUndo);
       }
     // Create a copy of the current object
     if (EcdClone(pitem->lpecdobject, lpclient,
         NULL, NULL, (LPECDOBJECT FAR *)&pObjectUndo->lpecdobject) != ECD_OK)
     LocalUnlock(hObjectUndo);
     LocalFree(hObjectUndo);
       hObjectUndo = NULL;
     }
   else{
     pObjectUndo->wType = pitem->wType;
     pObjectUndo->wUpdate = pitem->wUpdate;
     LocalUnlock(hObjectUndo);
     }
 }

 //---------------------------------------------------------------------------
 // ReadStream
 // Purpose: Read from an open file
 //---------------------------------------------------------------------------
 LONG FAR PASCAL ReadStream(LPAPPSTREAM lpStream, LPSTR lpstr, LONG cb)
 {
     return _lread(lpStream->fh, lpstr, (WORD)cb);
 }

 //---------------------------------------------------------------------------
 // WriteStream
 // Purpose: Write to an open file
 //---------------------------------------------------------------------------
 LONG FAR PASCAL WriteStream(LPAPPSTREAM lpStream, LPSTR lpstr, LONG cb)
 {
     return _lwrite(lpStream->fh, lpstr, (WORD)cb);
 }

 //---------------------------------------------------------------------------
 // PosStream
 // Purpose: Reposition file pointer
 //---------------------------------------------------------------------------
 LONG FAR PASCAL PosStream(LPAPPSTREAM lpStream, LONG pos)
 {
     return  _llseek(lpStream->fh, (LONG)pos, 0);
 }

 //---------------------------------------------------------------------------
 // StatusStream
 // Purpose: Returns the status of a file operation
 // Returns: NULL (Not implemented)
 //---------------------------------------------------------------------------
 WORD FAR PASCAL StatusStream(LPAPPSTREAM lpStream)
 {
     return NULL;
 }


 VOID SetRectSize(HWND hwnd, PITEM pitem){
   RECT rc, rc1;
   HDC hDC;
   short mm;

   if (!IsIconic(hwnd)){
     GetWindowRect(hwnd, &rc1);
       ScreenToClient(hwndMain, (LPPOINT) &rc1);
     hDC = GetDC(hwnd);
     mm = SetMapMode(hDC, MM_HIMETRIC);
     EcdQueryBounds(pitem->lpecdobject, &rc);
     LPtoDP(hDC, (LPPOINT)&rc, 2);
     SetMapMode(hDC, mm);
     if ((rc.right - rc.left == 0) || (rc.bottom - rc.top == 0)){
       rc.right = 200 ;
       rc.bottom = 200;
       rc.left = 0;
       rc.top = 0;
       }
     MoveWindow(hwnd, rc1.left, rc1.top, rc.right - rc.left,
       rc.bottom - rc.top + GetSystemMetrics(SM_CYCAPTION), TRUE);
     ReleaseDC(hwnd, hDC);
     }

 }



 /* Combine This function with PrintWindowTitle, lots of problems */

 void PrintLinkName(PITEM pitem, HWND hwnd){

   ECDSTATUS EcdStat;
     LPSTR pTitle, pTitle1;
    LPSTR lpstrInfo, lpstr1, lpstr2;
   HSTR hstr;

             if (((EcdStat = EcdGetData(pitem->lpecdobject,
                     (pitem->wType == IDM_PASTE) ? cfOwnerLink : cfLink,
                     &hstr))
                     == ECD_OK)
                 && hstr)
                 {
                 // Both link formats are:  "szClass szDocument szItem 0"
                 lpstrInfo = GlobalLock(hstr);
            lpstr1 = lpstrInfo;
            hWinTitle = GlobalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, 512);
            pTitle = pTitle1 = (LPSTR)GlobalLock(hWinTitle);
            while (*lpstr1){
             *(pTitle++) = *(lpstr1++);
             }
            *(pTitle++) = '\0';
            lpstr1 += 1;
                 SetWindowText(GetDlgItem(hwnd, IDD_LINKINFO), (LPSTR)pTitle1)
            nOffDocNm = pTitle - pTitle1;
           pTitle1 = pTitle;
            while (*lpstr1){
             *(pTitle++) = *(lpstr1++);
             }
            *(pTitle++) = '\0';
            lpstr1 += 1;
                 SetWindowText(GetDlgItem(hwnd, IDD_DOCNM), (LPSTR)pTitle1);

           nOffItemNm = pTitle - pTitle1 + nOffDocNm;
           pTitle1 = pTitle;
            while (*lpstr1){
             *(pTitle++) = *(lpstr1++);
             }
            *(pTitle++) = '\0';
            lpstr1 += 1;
                 SetWindowText(GetDlgItem(hwnd, IDD_ITEMNM), (LPSTR)pTitle1);

            GlobalUnlock(hWinTitle);
 //          LocalFree(hWinTitle);
                GlobalUnlock(hstr);
                 }
           }

 void SetData(PITEM pitem, HWND hDlg){
     char szObj[128];
     BOOL fSet = FALSE;
     LPSTR lpWinTitle;
     ECDSTATUS EcdStat;

     lpWinTitle = GlobalLock(hWinTitle);
     GetDlgItemText(hDlg, IDD_DOCNM, (LPSTR)szObj, 128);
     if (lstrcmpi((LPSTR)szObj, (LPSTR)(lpWinTitle + nOffDocNm))){
       lstrcpy((LPSTR)(lpWinTitle + nOffDocNm), (LPSTR)szObj);
       fSet = TRUE;
       }
     GetDlgItemText(hDlg, IDD_ITEMNM, (LPSTR)szObj, 128);
     if (lstrcmp((LPSTR)szObj, (LPSTR)(lpWinTitle + nOffItemNm))){
       lstrcpy((LPSTR)(lpWinTitle + nOffItemNm), (LPSTR)szObj);
       fSet = TRUE;
       }
     GlobalUnlock(hWinTitle);
     if (fSet){
       EcdStat = EcdSetData(pitem->lpecdobject,
                     (pitem->wType == IDM_PASTE) ? cfOwnerLink : cfLink,
               hWinTitle);
       PrintError(EcdStat);
       }
     }





 SERVER.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\MISHAPES\SERVER.C

 #define SERVERONLY
 #include "windows.h"
 #include "ecd.h"
 #include "shapes.h"

 //////////////////////////////////////////////////////////////////////////
 //
 // (c) Copyright Microsoft Corp. 1990 - All Rights Reserved
 //
 /////////////////////////////////////////////////////////////////////////


 // We alis the null item with the very first item in the file.
 // Since we never copy more than one item to clip board, there
 // is no problem for the objects being edited. If they are created
 // from template, we give the first child window back.


 extern      HANDLE  hInst;

 extern      char    *pcolors[];
 extern      char    *pshapes[];
 extern      HBRUSH  hbrColor [5];

 extern      WORD    cfLink;
 extern      WORD    cfOwnerLink;
 extern      WORD    cfNative;

 extern      WORD    cShapes;

 ECDDOCUMENTVTBL     docVTbl;
 ECDOBJECTVTBL       itemVTbl;
 ECDSERVERVTBL       srvrVTbl;


 void FreeVTbls ()
 {

     FreeProcInstance(srvrVTbl.Open);
     FreeProcInstance(srvrVTbl.Create);
     FreeProcInstance(srvrVTbl.CreateFromTemplate);
     FreeProcInstance(srvrVTbl.Edit);
     FreeProcInstance(srvrVTbl.Exit);
     FreeProcInstance(srvrVTbl.Release);

     FreeProcInstance (docVTbl.Save);
     FreeProcInstance (docVTbl.Close);
     FreeProcInstance (docVTbl.GetObject);
     FreeProcInstance (docVTbl.Release);

     FreeProcInstance (docVTbl.SetHostNames);
     FreeProcInstance (docVTbl.SetDocDimensions);


     FreeProcInstance (itemVTbl.Show);
     FreeProcInstance (itemVTbl.GetData);
     FreeProcInstance (itemVTbl.SetData);
     FreeProcInstance (itemVTbl.Delete);
     FreeProcInstance (itemVTbl.SetTargetDevice);
     FreeProcInstance (itemVTbl.EnumFormats);

 }

 void InitVTbls ()
 {

     // srvr vtable.

     srvrVTbl.Open    = MakeProcInstance(SrvrOpen, hInst);
     srvrVTbl.Create  = MakeProcInstance(SrvrCreate, hInst);
     srvrVTbl.CreateFromTemplate = MakeProcInstance(SrvrCreateFromTemplate, hI
     srvrVTbl.Edit    = MakeProcInstance(SrvrEdit, hInst);
     srvrVTbl.Exit    = MakeProcInstance(SrvrExit, hInst);
     srvrVTbl.Release = MakeProcInstance(SrvrRelease, hInst);

     // doc table
     docVTbl.Save       = MakeProcInstance(DocSave, hInst);
     docVTbl.Close      = MakeProcInstance(DocClose, hInst);
     docVTbl.GetObject  = MakeProcInstance(DocGetObject, hInst);
     docVTbl.Release    = MakeProcInstance(DocRelease, hInst);

     docVTbl.SetHostNames        = MakeProcInstance(DocSetHostNames, hInst);
     docVTbl.SetDocDimensions    = MakeProcInstance(DocSetDocDimensions, hInst

     // item table.

     itemVTbl.Show      = MakeProcInstance (ItemOpen, hInst);
     itemVTbl.GetData   = MakeProcInstance (ItemGetData, hInst);
     itemVTbl.SetData   = MakeProcInstance (ItemSetData, hInst);
     itemVTbl.Delete    = MakeProcInstance (ItemDelete, hInst);

     itemVTbl.SetTargetDevice =  MakeProcInstance (ItemSetTargetDevice, hInst)
     itemVTbl.EnumFormats =  MakeProcInstance (ItemEnumFormats, hInst);

 }

 BOOL ProcessCmdLine (hwnd, lpcmdline)
 LPSTR   lpcmdline;
 HWND    hwnd;
 {

     // Look for any file name on the command line.
     char    buf[100];
     int      i;

     while (*lpcmdline){
         // skip blanks
         while ( *lpcmdline && *lpcmdline == ' ')
             lpcmdline++;

         if (*lpcmdline == '-' || *lpcmdline == '/'){
             // skip the options.
             while ( *lpcmdline && *lpcmdline != ' ')
                 lpcmdline++;


         } else {
             // looks like we found the file name. terminate with NULL and
             // open the document.

             // !!! check for the buffer limits.

             i = 0;
             while ( *lpcmdline && *lpcmdline != ' ')
                 buf[i++] =*lpcmdline++;

             buf[i] = 0;

            // now open the document.
            if(CreateDocFromFile ((PSRVR)GetWindowLong (hwnd, 0),
                 (LPSTR)buf, NULL))
                 return TRUE;
             else
                 return FALSE;
         }
     }
     return TRUE;


 }

 BOOL InitServer (hwnd, hInst)
 HWND    hwnd;
 HANDLE  hInst;
 {


     HANDLE      hsrvr = NULL;
     PSRVR       psrvr = NULL;
     int         retval;

     hsrvr = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (SRVR));

     if (hsrvr == NULL || (psrvr = (PSRVR) LocalLock (hsrvr)) == NULL)
         goto errRtn;

     psrvr->hsrvr = hsrvr;

     psrvr->ecdsrvr.lpvtbl = &srvrVTbl;

     retval = EcdRegisterServer ((LPSTR)"miShapes", (LPECDSERVER)psrvr,
                 (LONG FAR *) &psrvr->lhsrvr, hInst, ECD_SRVR_MULTI);


     if (retval != ECD_OK)
         goto errRtn;

     psrvr->hwnd = hwnd;        // corresponding main window
     SetWindowLong (hwnd, 0, (LONG)(LPSRVR)psrvr);
     return TRUE;

 errRtn:
     if (psrvr)
         LocalUnlock (hsrvr);

     if (hsrvr)
         LocalFree (hsrvr);

     return FALSE;

 }

 int     FAR     PASCAL SrvrRelease (lpecdsrvr)
 LPECDSERVER   lpecdsrvr;
 {

     PSRVR   psrvr;
     HANDLE  hsrvr;
     HWND    hwnd;


     psrvr = (PSRVR)((LPSRVR)lpecdsrvr);

     if (psrvr->lhsrvr)
         DeleteServer (psrvr);

     else {
         // This delete server should release the server immediately
         hwnd = psrvr->hwnd;
         LocalUnlock (hsrvr = psrvr->hsrvr);
         LocalFree (hsrvr);
         DestroyWindow(hwnd);
     }
     return TRUE;    // return something
 }

 void DeleteServer (psrvr)
 PSRVR   psrvr;
 {
      LHSERVER lhsrvr;


 #ifdef TEST
      EcdRevokeServer ((LHSERVER)psrvr);
 #else

      lhsrvr = psrvr->lhsrvr;
      psrvr->lhsrvr = NULL;
      if (lhsrvr){
         ShowWindow (psrvr->hwnd, FALSE);
         EcdRevokeServer (lhsrvr);
      }
 #endif
 }

 int     FAR     PASCAL SrvrOpen (lpecdsrvr, lhdoc, lpdocname, lplpecddoc)
 LHDOCUMENT     lhdoc;
 LPECDSERVER    lpecdsrvr;
 LPSTR          lpdocname;
 LPECDDOCUMENT FAR *lplpecddoc;
 {
     PDOC    pdoc;


     PROBE_BUSY(bBusy);

     // errors are not taken care properly
     if(!(pdoc = CreateDocFromFile ((PSRVR)((LPSRVR)lpecdsrvr), lpdocname, lhd
         return ECD_ERROR_MEMORY;

     *lplpecddoc = (LPECDDOCUMENT)pdoc;
     return ECD_OK;

 }


 int     FAR     PASCAL SrvrCreate (lpecdsrvr, lhdoc, lpclassname, lpdocname,
 LHDOCUMENT         lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

    PDOC pdoc;
    // errors are not taken care properly

    PROBE_BUSY(bBusy);

    if (!(pdoc = CreateNewDoc ((PSRVR)lpecdsrvr, lhdoc, lpdocname)))
         return ECD_ERROR_MEMORY;

    CreateNewItem (pdoc, IDM_RECT, IDM_RED, TRUE);
    *lplpecddoc = (LPECDDOCUMENT)pdoc;

    return ECD_OK;

 }

 int     FAR     PASCAL SrvrCreateFromTemplate (lpecdsrvr, lhdoc, lpclassname,
 LHDOCUMENT    lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPSTR         lptemplatename;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

     PDOC    pdoc;

     PROBE_BUSY(bBusy);

     if(!(pdoc = CreateDocFromFile ((PSRVR)lpecdsrvr, lptemplatename, lhdoc)))
         return ECD_ERROR_MEMORY;

     ChangeDocName (pdoc, (LPSTR)lptemplatename);
     *lplpecddoc = (LPECDDOCUMENT)pdoc;
     return ECD_OK;

 }

 int     FAR     PASCAL SrvrEdit (lpecdsrvr, lhdoc, lpclassname, lpdocname, lp
 LHDOCUMENT    lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

    PDOC pdoc;

    PROBE_BUSY(bBusy);

    // errors are not taken care properly

    if (!(pdoc = CreateNewDoc ((PSRVR)lpecdsrvr, lhdoc, lpdocname)))
         return ECD_ERROR_MEMORY;

    *lplpecddoc = (LPECDDOCUMENT)pdoc;

    return ECD_OK;


 }

 int     FAR     PASCAL SrvrExit (lpecdsrvr)
 LPECDSERVER   lpecdsrvr;
 {

     // Server lib is calling us to exit.
     // Let us hide the main window.
     // But let us not delete the window.
     PSRVR   psrvr;

     PROBE_BUSY(bBusy);

     psrvr = (PSRVR)lpecdsrvr;

     ShowWindow (psrvr->hwnd, FALSE);
     EcdRevokeServer (psrvr->lhsrvr);
     return ECD_OK;



 }

 // doucment functions.

 PDOC    InitDoc (hwnd, lhdoc)
 HWND        hwnd;
 LHDOCUMENT  lhdoc;
 {
     HANDLE      hdoc = NULL;
     PDOC        pdoc = NULL;
     char        buf[128];
     PSRVR       psrvr;



     hdoc = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (DOC));

     if (hdoc == NULL || (pdoc = (PDOC) LocalLock (hdoc)) == NULL)
         goto errRtn;

     pdoc->hdoc = hdoc;
     pdoc->hwnd = hwnd;        // corresponding main window

     psrvr = (PSRVR)GetWindowLong (GetParent (hwnd), 0);
     GetWindowText (hwnd, (LPSTR)buf, 128);
     if (lhdoc == NULL){
         if (EcdRegisterDocument (psrvr->lhsrvr, (LPSTR)buf, (LPECDDOCUMENT)pd
             (LHDOCUMENT FAR *)&pdoc->lhdoc) != ECD_OK)
             goto errRtn;
     } else
         pdoc->lhdoc = lhdoc;

     pdoc->aName = GlobalAddAtom ((LPSTR)buf);
     SetWindowLong (hwnd, 0, (LONG)pdoc);

     pdoc->ecddoc.lpvtbl = &docVTbl;

     // set the anchor point for children
     pdoc->ptAnchor.x = 0;
     pdoc->ptAnchor.y = 0;

     return pdoc;

 errRtn:

     if (pdoc)
         LocalUnlock (hdoc);

     if (hdoc)
         LocalFree;

     return (PDOC)NULL;

 }


 int FAR PASCAL  DocSave (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {

     PROBE_BUSY(bBusy);
     // not yet implemented
     return ECD_OK;


 }

 void DeleteDoc (pdoc)
 PDOC    pdoc;
 {
     LHDOCUMENT   lhdoc;

 #ifdef TEST
     EcdRevokeDocument ((LHDOCUMENT)pdoc);

 #else
     lhdoc = pdoc->lhdoc;
     pdoc->lhdoc = NULL;
     if (lhdoc) {
         ShowWindow (pdoc->hwnd, FALSE);
         EcdRevokeDocument (lhdoc);
     }
 #endif

 }


 int FAR PASCAL  DocClose (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {
     PDOC    pdoc;

     PROBE_BUSY(bBusy);
     pdoc = (PDOC)lpecddoc;

     SendDocChangeMsg (pdoc, ECD_CLOSED);
     DeleteDoc (pdoc);
     return ECD_OK;

 }

 int FAR PASCAL DocSetHostNames(lpecddoc, lpclientName, lpdocName)
 LPECDDOCUMENT    lpecddoc;
 LPSTR            lpclientName;
 LPSTR            lpdocName;
 {


     PDOC    pdoc;
     char    buf[200];
     int     len;
     HWND    hwnd;

     PROBE_BUSY(bBusy);

     // Do something to show that the titiel are chaning
     pdoc = (PDOC)lpecddoc;
     hwnd = pdoc->hwnd;

     SetWindowText (hwnd, lpdocName);;

     hwnd = GetParent (hwnd);
     lstrcpy ((LPSTR)buf, lpclientName);
     lstrcat ((LPSTR)buf, (LPSTR)":");
     lstrcat ((LPSTR)buf, (LPSTR)"Sample mishapes server application");
     len = lstrlen ((LPSTR)buf);
     SetWindowText (hwnd, (LPSTR)buf);

     return ECD_OK;

 }
 int FAR PASCAL DocSetDocDimensions(lpecddoc, lprc)
 LPECDDOCUMENT   lpecddoc;
 LPRECT  lprc;
 {
     PROBE_BUSY(bBusy);
     return ECD_OK;


 }

 int FAR PASCAL  DocRelease (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {

     // !!! what is this supposed to do?
     // Revoke document calls DocRelease.

     PDOC    pdoc;
     HANDLE  hdoc;
     HWND    hwnd;


     PROBE_BUSY(bBusy);

     pdoc = (PDOC)lpecddoc;
     GlobalDeleteAtom (pdoc->aName);
     hwnd = pdoc->hwnd;
     LocalUnlock (hdoc = pdoc->hdoc);
     LocalFree (hdoc);
     DestroyWindow(hwnd);
     return TRUE;        // return something

 }

 int ChangeDocName (pdoc, lpname)
 PDOC    pdoc;
 LPSTR   lpname;
 {

     GlobalDeleteAtom (pdoc->aName);
     pdoc->aName = GlobalAddAtom (lpname);
     SetWindowText (pdoc->hwnd, lpname);
     return TRUE;        // return something

 }


 int FAR PASCAL  DocGetObject (lpecddoc, lpitemname, lplpecdobject, lpecdclien
 LPECDDOCUMENT       lpecddoc;
 LPSTR               lpitemname;
 LPECDOBJECT FAR *   lplpecdobject;
 LPECDCLIENT         lpecdclient;
 {
     PDOC    pdoc;
     HWND    hwnd;
     ATOM    aName;
     PITEM   pitem;


     PROBE_BUSY(bBusy);

     pdoc  = (PDOC)lpecddoc;
     aName = GlobalFindAtom (lpitemname);
     hwnd = GetWindow ((hwnd = pdoc->hwnd), GW_CHILD);

     // go thru all the child window list and find the window which is
     // matching the given item name.

     while (hwnd){

        // !!! We are trying to match the doc item with any item
        // OK only if there is only one item in a doc. Otherwise
        // we will be in troubles. Should work without any problems.
        // for embedded objects.

         pitem = (PITEM)GetWindowLong (hwnd, 0);

         // Alias the null with the very first item
         if (pitem->aName == aName || pitem->aName == NULL || aName == NULL)
             goto rtn;

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }
     // we did not find the item we wanted. So, create one

     // create a window with empty native data.

     if (CreateNewItem (pdoc, IDM_RECT, IDM_RED, FALSE)) {
         // newly created window is always the first child
         pitem = (PITEM)GetWindowLong (GetWindow (pdoc->hwnd, GW_CHILD), 0);
         BringWindowToTop (pitem->hwnd);
     } else
         return ECD_ERROR_MEMORY;
 rtn:
     pitem->aName = GlobalAddAtom (lpitemname);
     // If the item is not null, then do not show the window.
     *lplpecdobject = (LPECDOBJECT)pitem;
     pitem->lpecdclient = lpecdclient;
     return ECD_OK;

 }


 // item related routines

 void SetNewItemName (pitem)
 PITEM   pitem;
 {
     char    buf[3];

     lstrcpy ((LPSTR)pitem->name, (LPSTR)"Shape #");


     if (cShapes++ > 100)
         cShapes = 1;

     buf[0] = (char)((cShapes / 10)  + (int)'0');
     buf[1] = (char)((cShapes % 10)  + (int)'0');
     buf[2] = 0;

     lstrcat ((LPSTR)pitem->name, (LPSTR)buf);
     pitem->aName = GlobalAddAtom ((LPSTR)pitem->name);
 }

 void SetItemName (pitem, lpname)
 PITEM   pitem;
 LPSTR   lpname;
 {
     pitem->aName = GlobalAddAtom (lpname);
     lstrcpy ((LPSTR)pitem->name, lpname);
 }

 void CutCopyItem (hwnd)
 HWND    hwnd;
 {
     PITEM       pitem;

     if (OpenClipboard (hwnd)){

         EmptyClipboard ();

         // firt set the clipboard

         pitem = (PITEM) GetWindowLong (GetWindow(
                 GetWindow (hwnd, GW_CHILD), GW_CHILD), 0);

         // Check for null handles from the render routines.
         SetClipboardData (CF_METAFILEPICT, GetPicture (pitem));
         SetClipboardData (CF_BITMAP, GetBitmap (pitem));
         SetClipboardData (cfNative, GetNative (pitem));
         SetClipboardData (cfLink, GetLink (pitem));
         SetClipboardData (cfOwnerLink, GetLink (pitem));
         CloseClipboard ();
     }


 }

 HANDLE  GetNative (pitem)
 PITEM   pitem;
 {


     LPSTR       lpsrc;
     LPSTR       lplink = NULL;
     HANDLE      hlink = NULL;
     int         i;



     hlink = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, sizeof (ITEM));
     if (hlink== NULL || (lplink = (LPSTR)GlobalLock (hlink)) == NULL)
         goto errRtn;

     lpsrc = (LPSTR)pitem;
     for (i = 0; i <  sizeof(ITEM); i++)
         *lplink++ = *lpsrc++;

     GlobalUnlock (hlink);
     return hlink;

 errRtn:
     if (lplink)
         GlobalUnlock (hlink);

     if (hlink)
         GlobalFree (hlink);

 }

 HANDLE  GetLink (pitem)
 PITEM   pitem;
 {

     char        buf[128];
     LPSTR       lpsrc;
     LPSTR       lplink = NULL;
     HANDLE      hlink = NULL;
     int         len;
     int         i;

     // make the link
     lstrcpy ((LPSTR)buf, (LPSTR)"miShapes");
     len = lstrlen ((LPSTR)buf) + 1;
     len += GetWindowText (GetParent (pitem->hwnd), (LPSTR)buf + len , 128 - l
     len += GlobalGetAtomName (pitem->aName, (LPSTR)buf + len, 128 - len) + 1;
     buf[len++] = 0;       // throw in another null at the end.


     hlink = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, len);
     if (hlink== NULL || (lplink = (LPSTR)GlobalLock (hlink)) == NULL)
         goto errRtn;

     lpsrc = (LPSTR)buf;
     for (i = 0; i <  len; i++)
         *lplink++ = *lpsrc++;

     GlobalUnlock (hlink);

     return hlink;
 errRtn:
     if (lplink)
         GlobalUnlock (hlink);

     GlobalFree (hlink);
     return NULL;
 }

 HANDLE     GetPicture (pitem)
 PITEM       pitem;
 {

     LPMETAFILEPICT  lppict = NULL;
     HANDLE          hpict = NULL;
     HANDLE          hMF = NULL;
     HANDLE          hdc;
     RECT            rc;
     HPEN            hpen;
     HPEN            holdpen;
     int             mm;


     // Now set the bitmap data.

     hdc = CreateMetaFile(NULL);

     GetClientRect (pitem->hwnd, (LPRECT)&rc);

     // paint directly into the bitmap
     SelectObject (hdc, hbrColor [ pitem->cmdColor - IDM_RED]);
     PatBlt (hdc, 0,0, rc.right, rc.bottom, WHITENESS);
     SetWindowOrg (hdc, 0, 0);
     SetWindowExt (hdc, rc.right, rc.bottom);


     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdc, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }

     hMF = CloseMetaFile (hdc);

     if(!(hpict = GlobalAlloc (GMEM_DDESHARE, sizeof (METAFILEPICT))))
         goto errRtn;

     if ((lppict = (LPMETAFILEPICT)GlobalLock (hpict)) == NULL)
         goto errRtn;

     lppict->mm = MM_ANISOTROPIC;
     lppict->hMF = hMF;


     hdc = GetDC (pitem->hwnd);
     mm = SetMapMode(hdc, MM_HIMETRIC);
     DPtoLP(hdc, (LPPOINT)&rc, 2);
     SetMapMode(hdc, mm);
     ReleaseDC (pitem->hwnd, hdc);

     lppict->xExt =  rc.right - rc.left;
     lppict->yExt =  rc.top - rc.bottom;
     GlobalUnlock (hpict);
     return hpict;

 errRtn:
     if (lppict)
         GlobalUnlock (hpict);

     if (hpict)
         GlobalFree (hpict);

     if (hMF)
         DeleteMetaFile (hMF);
     return NULL;

 }


 HBITMAP     GetBitmap (pitem)
 PITEM       pitem;
 {

     HDC         hdc;
     HDC         hdcmem;
     RECT        rc;
     HBITMAP     hbitmap;
     HBITMAP     holdbitmap;
     HPEN        hpen;
     HPEN        holdpen;


     // Now set the bitmap data.

     hdc = GetDC (pitem->hwnd);
     hdcmem = CreateCompatibleDC (hdc);
     GetClientRect (pitem->hwnd, (LPRECT)&rc);
     hbitmap = CreateCompatibleBitmap (hdc, rc.right - rc.left, rc.bottom - rc
     holdbitmap = SelectObject (hdcmem, hbitmap);

     // paimt directly into the bitmap
     SelectObject (hdcmem, hbrColor [ pitem->cmdColor - IDM_RED]);
     PatBlt (hdcmem, 0,0, rc.right, rc.bottom, WHITENESS);

     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdcmem, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdcmem, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdcmem, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdcmem, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdcmem, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdcmem, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdcmem, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }



     hbitmap = SelectObject (hdcmem, holdbitmap);
     hpen = SelectObject (hdcmem, holdpen);
     DeleteObject (hpen);
     DeleteDC (hdcmem);
     ReleaseDC (pitem->hwnd, hdc);
     return hbitmap;

 }

 PITEM   CreateNewItem (pdoc, cmdShape, cmdColor, bVisible)
 PDOC    pdoc;
 int     cmdShape;
 int     cmdColor;
 BOOL    bVisible;
 {

     RECT        rc;
     HANDLE      hitem = NULL;
     PITEM       pitem = NULL;
     HWND        hwnd;



     GetClientRect (pdoc->hwnd, (LPRECT)&rc);

     hwnd = CreateWindow(
         "ItemClass",
         "Item",

         WS_DLGFRAME| WS_CHILD | WS_CLIPSIBLINGS |
                     (bVisible ? WS_VISIBLE : 0),
         pdoc->ptAnchor.x,
         pdoc->ptAnchor.y,
         (rc.right - rc.left) >> 1,
         (rc.bottom - rc.top)>> 1,
         pdoc->hwnd,
         NULL,
         hInst,
         NULL
     );


     if (!hwnd)
         return (FALSE);

     pdoc->ptAnchor.x += 20;
     pdoc->ptAnchor.y += 20;


     // Now create the item info;
     hitem = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITEM));

     if (hitem == NULL || ((pitem = (PITEM)LocalLock (hitem)) == NULL))
         goto  errRtn;

     pitem->cmdShape = cmdShape;;
     pitem->cmdColor = cmdColor;
     pitem->hitem    = hitem;
     pitem->aName    = NULL;
     pitem->hwnd     = hwnd;
     pitem->ecdobject.lpvtbl = &itemVTbl;

     pitem->width    = (rc.right - rc.left) >> 1;
     pitem->height   = (rc.bottom - rc.top) >> 1;

     SetWindowLong (hwnd, 0, (LONG)pitem);
     return pitem;

  errRtn:
     if (pitem)
         LocalUnlock (hitem);

     if (hitem)
         LocalFree (hitem);

     return (PITEM)NULL;

 }

 int FAR PASCAL  ItemOpen (lpecdobject)
 LPECDOBJECT     lpecdobject;
 {

     // !!! This routine should activate the app
     // and prepare it ready for the editing. Activation
     // should bring on to the top and restore


     PITEM   pitem;
     HWND    hwnd;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;
     BringWindowToTop (pitem->hwnd);
     BringWindowToTop (GetParent (pitem->hwnd));
     SetActiveWindow ((hwnd = GetParent (GetParent (pitem->hwnd))));
     SendMessage (hwnd, WM_SYSCOMMAND, SC_RESTORE, 0L);
     return ECD_OK;


 }


 int FAR PASCAL  ItemDelete (lpecdobject)
 LPECDOBJECT     lpecdobject;
 {

     PITEM   pitem;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;
     if (--pitem->ref)
         return ECD_OK;

     if (IsWindow(pitem->hwnd))
         DestroyWindow (pitem->hwnd);
     return ECD_OK;
 }


 int FAR PASCAL  ItemGetData (lpecdobject, cfFormat, lphandle)
 LPECDOBJECT     lpecdobject;
 WORD            cfFormat;
 LPHANDLE        lphandle;
 {

     PITEM   pitem;

     // PROBE_BUSY(bBusy);

     // asking data for emtyp object.
     pitem = (PITEM)lpecdobject;

     if (pitem->cmdShape  == NULL||
         pitem->cmdColor == NULL)
         return ECD_ERROR_MEMORY;

     if (cfFormat == cfNative){

         if (!(*lphandle = GetNative (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }


     if (cfFormat == CF_BITMAP){

         if (!(*lphandle = (HANDLE)GetBitmap (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }

     if (cfFormat == CF_METAFILEPICT){

         if (!(*lphandle = GetPicture (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }

     if (cfFormat == cfLink || cfFormat == cfOwnerLink){

         if (!(*lphandle = GetLink (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }
     return ECD_ERROR_MEMORY;          // this is actually unknow format.

 }


 int FAR PASCAL   ItemSetTargetDevice (lpecdobject, hdata)
 LPECDOBJECT     lpecdobject;
 HANDLE          hdata;
 {
     LPSTR   lpdata;

     lpdata = (LPSTR)GlobalLock (hdata);
     // Print the lpdata here.
     GlobalUnlock (hdata);
     GlobalFree (hdata);
     return ECD_OK;

 }

 int FAR PASCAL  ItemSetData (lpecdobject, cfFormat, hdata)
 LPECDOBJECT     lpecdobject;
 WORD            cfFormat;
 HANDLE          hdata;
 {

     LPITEM   lpitem;
     PITEM    pitem;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;

     if (cfFormat != cfNative)
         return ECD_ERROR_MEMORY;


     lpitem = (LPITEM)GlobalLock (hdata);
     if (lpitem){
         pitem->cmdShape = lpitem->cmdShape;
         pitem->cmdColor = lpitem->cmdColor;
         SetItemName (pitem, (LPSTR)pitem->name);
         // This is not necessary.
         ShowWindow (pitem->hwnd, TRUE);
         InvalidateRect (pitem->hwnd, (LPRECT)NULL, TRUE);
         GlobalUnlock (hdata);
     }

     GlobalFree (hdata);
     return ECD_OK;
 }

 ECDCLIPFORMAT   FAR PASCAL ItemEnumFormats (lpecdobject, cfFormat)
 LPECDOBJECT     lpecdobject;
 ECDCLIPFORMAT   cfFormat;
 {
     if (cfFormat == 0)
         return cfLink;

     if (cfFormat == cfLink)
         return cfOwnerLink;

     if (cfFormat == cfOwnerLink)
         return CF_BITMAP;

     if (cfFormat == CF_BITMAP)
         return CF_METAFILEPICT;

     if (cfFormat == CF_METAFILEPICT)
         return cfNative;

     //if (cfFormat == cfNative)
     //    return NULL;

     return NULL;
 }

 BOOL DestroyItem (hwnd)
 HWND    hwnd;
 {
     PITEM   pitem;
     HANDLE  hitem;


     pitem = (PITEM)GetWindowLong (hwnd, 0);
     if (pitem->aName)
         GlobalDeleteAtom (pitem->aName);

     LocalUnlock (hitem = pitem->hitem);
     LocalFree (hitem);
     return TRUE;        // return something

 }

 void    PaintItem (hwnd)
 HWND    hwnd;
 {

     HDC             hdc;
     PITEM           pitem;
     RECT            rc;
     PAINTSTRUCT     ptSt;
     HPEN            hpen;
     HPEN            holdpen;


     BeginPaint (hwnd, (LPPAINTSTRUCT)&ptSt);
     hdc = GetDC (hwnd);

     // Do not paint anything for the whole document item
     // For document item the name is null.

     pitem = (PITEM)GetWindowLong (hwnd, 0);

     GetClientRect (hwnd, (LPRECT)&rc);
     PatBlt (hdc, 0,0, rc.right, rc.bottom, WHITENESS);
     SelectObject (hdc, hbrColor [ pitem->cmdColor - IDM_RED]);
     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdc, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }

     hpen = SelectObject (hdc, holdpen);
     DeleteObject (hpen);

     ReleaseDC (hwnd, hdc);
     EndPaint (hwnd, (LPPAINTSTRUCT)&ptSt);
 }



 void    SendSrvrChangeMsg (psrvr, options)
 PSRVR   psrvr;
 WORD    options;
 {

     HWND    hwnd;

     // if we are releasing the document, do not do anything
     if (psrvr->lhsrvr == NULL)
         return;

     hwnd = GetWindow (psrvr->hwnd, GW_CHILD);
     while (hwnd){
         SendDocChangeMsg ((PDOC)GetWindowLong (hwnd, 0), options);
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);

     }

 }

 void    SendDocRenameMsg (psrvr, options)
 PSRVR   psrvr;
 WORD    options;
 {

     HWND    hwnd;
     PITEM   pitem;
     PDOC    pdoc;
     char    buf[128];

     // if we are releasing the document, do not do anything
     if (psrvr->lhsrvr == NULL)
         return;

     hwnd = GetWindow (psrvr->hwnd, GW_CHILD);
     pdoc = (PDOC)GetWindowLong (hwnd, 0);

     // if we are releasing the document, do not do anything
     if (pdoc->lhdoc == NULL)
         return;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);

     while (hwnd){
         pitem = (PITEM)GetWindowLong (hwnd, 0);
         // Sending rename to obe item is sufficient
         if (pitem->lpecdclient){
             (*pitem->lpecdclient->lpvtbl->CallBack) (pitem->lpecdclient, opti
                     (LPECDOBJECT)pitem);

             return;
         }
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

     // reregister the document if there are no callbacks.
     GetWindowText (pdoc->hwnd, (LPSTR)buf, 128);
     DeleteDoc (pdoc);
     CreateDocFromFile (psrvr, (LPSTR)buf, NULL);
     return;
 }

 void    SendDocChangeMsg (pdoc, options)
 PDOC    pdoc;
 WORD    options;
 {

     HWND    hwnd;

     // if we are releasing the document, do not do anything
     if (pdoc->lhdoc == NULL)
         return;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);
     while (hwnd){
         SendItemChangeMsg ((PITEM)GetWindowLong (hwnd, 0), options);
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);

     }

 }


 void    SendItemChangeMsg (pitem, options)
 PITEM   pitem;
 WORD    options;
 {

     if (pitem->lpecdclient)
         (*pitem->lpecdclient->lpvtbl->CallBack) (pitem->lpecdclient, options,
                 (LPECDOBJECT)pitem);
 }


 SERVER.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\SHAPES\SERVER.C

 #define SERVERONLY
 #include "windows.h"
 #include "ecd.h"
 #include "shapes.h"

 //////////////////////////////////////////////////////////////////////////
 //
 // (c) Copyright Microsoft Corp. 1990 - All Rights Reserved
 //
 /////////////////////////////////////////////////////////////////////////


 // We alis the null item with the very first item in the file.
 // Since we never copy more than one item to clip board, there
 // is no problem for the objects being edited. If they are created
 // from template, we give the first child window back.


 extern      HANDLE  hInst;

 extern      char    *pcolors[];
 extern      char    *pshapes[];
 extern      HBRUSH  hbrColor [5];

 extern      WORD    cfLink;
 extern      WORD    cfOwnerLink;
 extern      WORD    cfNative;

 extern      WORD    cShapes;

 ECDDOCUMENTVTBL     docVTbl;
 ECDOBJECTVTBL       itemVTbl;
 ECDSERVERVTBL       srvrVTbl;


 void FreeVTbls ()
 {

     FreeProcInstance(srvrVTbl.Open);
     FreeProcInstance(srvrVTbl.Create);
     FreeProcInstance(srvrVTbl.CreateFromTemplate);
     FreeProcInstance(srvrVTbl.Edit);
     FreeProcInstance(srvrVTbl.Exit);
     FreeProcInstance(srvrVTbl.Release);

     FreeProcInstance (docVTbl.Save);
     FreeProcInstance (docVTbl.Close);
     FreeProcInstance (docVTbl.GetObject);
     FreeProcInstance (docVTbl.Release);

     FreeProcInstance (docVTbl.SetHostNames);
     FreeProcInstance (docVTbl.SetDocDimensions);


     FreeProcInstance (itemVTbl.Show);
     FreeProcInstance (itemVTbl.GetData);
     FreeProcInstance (itemVTbl.SetData);
     FreeProcInstance (itemVTbl.Delete);
     FreeProcInstance (itemVTbl.SetTargetDevice);
     FreeProcInstance (itemVTbl.EnumFormats);

 }

 void InitVTbls ()
 {

     // srvr vtable.

     srvrVTbl.Open    = MakeProcInstance(SrvrOpen, hInst);
     srvrVTbl.Create  = MakeProcInstance(SrvrCreate, hInst);
     srvrVTbl.CreateFromTemplate = MakeProcInstance(SrvrCreateFromTemplate, hI
     srvrVTbl.Edit    = MakeProcInstance(SrvrEdit, hInst);
     srvrVTbl.Exit    = MakeProcInstance(SrvrExit, hInst);
     srvrVTbl.Release = MakeProcInstance(SrvrRelease, hInst);

     // doc table
     docVTbl.Save       = MakeProcInstance(DocSave, hInst);
     docVTbl.Close      = MakeProcInstance(DocClose, hInst);
     docVTbl.GetObject  = MakeProcInstance(DocGetObject, hInst);
     docVTbl.Release    = MakeProcInstance(DocRelease, hInst);

     docVTbl.SetHostNames        = MakeProcInstance(DocSetHostNames, hInst);
     docVTbl.SetDocDimensions    = MakeProcInstance(DocSetDocDimensions, hInst

     // item table.

     itemVTbl.Show      = MakeProcInstance (ItemOpen, hInst);
     itemVTbl.GetData   = MakeProcInstance (ItemGetData, hInst);
     itemVTbl.SetData   = MakeProcInstance (ItemSetData, hInst);
     itemVTbl.Delete    = MakeProcInstance (ItemDelete, hInst);

     itemVTbl.SetTargetDevice =  MakeProcInstance (ItemSetTargetDevice, hInst)
     itemVTbl.EnumFormats =  MakeProcInstance (ItemEnumFormats, hInst);

 }

 BOOL ProcessCmdLine (hwnd, lpcmdline)
 LPSTR   lpcmdline;
 HWND    hwnd;
 {

     // Look for any file name on the command line.
     char    buf[100];
     int      i;

     while (*lpcmdline){
         // skip blanks
         while ( *lpcmdline && *lpcmdline == ' ')
             lpcmdline++;

         if (*lpcmdline == '-' || *lpcmdline == '/'){
             // skip the options.
             while ( *lpcmdline && *lpcmdline != ' ')
                 lpcmdline++;


         } else {
             // looks like we found the file name. terminate with NULL and
             // open the document.

             // !!! check for the buffer limits.

             i = 0;
             while ( *lpcmdline && *lpcmdline != ' ')
                 buf[i++] =*lpcmdline++;

             buf[i] = 0;

            // now open the document.
            if(CreateDocFromFile ((PSRVR)GetWindowLong (hwnd, 0),
                 (LPSTR)buf, NULL))
                 return TRUE;
             else
                 return FALSE;
         }
     }
     return TRUE;


 }

 BOOL InitServer (hwnd, hInst)
 HWND    hwnd;
 HANDLE  hInst;
 {


     HANDLE      hsrvr = NULL;
     PSRVR       psrvr = NULL;
     int         retval;

     hsrvr = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (SRVR));

     if (hsrvr == NULL || (psrvr = (PSRVR) LocalLock (hsrvr)) == NULL)
         goto errRtn;

     psrvr->hsrvr = hsrvr;

     psrvr->ecdsrvr.lpvtbl = &srvrVTbl;

     retval = EcdRegisterServer ((LPSTR)"Shapes", (LPECDSERVER)psrvr,
                 (LONG FAR *) &psrvr->lhsrvr, hInst, ECD_SRVR_SINGLE);


     if (retval != ECD_OK)
         goto errRtn;

     psrvr->hwnd = hwnd;        // corresponding main window
     SetWindowLong (hwnd, 0, (LONG)(LPSRVR)psrvr);
     return TRUE;

 errRtn:
     if (psrvr)
         LocalUnlock (hsrvr);

     if (hsrvr)
         LocalFree (hsrvr);

     return FALSE;

 }

 int     FAR     PASCAL SrvrRelease (lpecdsrvr)
 LPECDSERVER   lpecdsrvr;
 {

     PSRVR   psrvr;
     HANDLE  hsrvr;
     HWND    hwnd;


     psrvr = (PSRVR)((LPSRVR)lpecdsrvr);
     if (psrvr->lhsrvr)
         DeleteServer (psrvr);

     else {
         // This delete server should release the server immediately
         hwnd = psrvr->hwnd;
         LocalUnlock (hsrvr = psrvr->hsrvr);
         LocalFree (hsrvr);
         DestroyWindow(hwnd);
     }
     return TRUE;    // return something
 }

 void DeleteServer (psrvr)
 PSRVR   psrvr;
 {
      LHSERVER lhsrvr;


 #ifdef TEST
      EcdRevokeServer ((LHSERVER)psrvr);
 #else

      lhsrvr = psrvr->lhsrvr;
      psrvr->lhsrvr = NULL;
      if (lhsrvr){
         ShowWindow (psrvr->hwnd, FALSE);
         EcdRevokeServer (lhsrvr);
      }
 #endif
 }

 int     FAR     PASCAL SrvrOpen (lpecdsrvr, lhdoc, lpdocname, lplpecddoc)
 LHDOCUMENT     lhdoc;
 LPECDSERVER    lpecdsrvr;
 LPSTR          lpdocname;
 LPECDDOCUMENT FAR *lplpecddoc;
 {
     PDOC    pdoc;


     PROBE_BUSY(bBusy);

     // errors are not taken care properly
     if(!(pdoc = CreateDocFromFile ((PSRVR)((LPSRVR)lpecdsrvr), lpdocname, lhd
         return ECD_ERROR_MEMORY;

     *lplpecddoc = (LPECDDOCUMENT)pdoc;
     return ECD_OK;

 }


 int     FAR     PASCAL SrvrCreate (lpecdsrvr, lhdoc, lpclassname, lpdocname,
 LHDOCUMENT         lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

    PDOC pdoc;
    // errors are not taken care properly

    PROBE_BUSY(bBusy);

    if (!(pdoc = CreateNewDoc ((PSRVR)lpecdsrvr, lhdoc, lpdocname)))
         return ECD_ERROR_MEMORY;

    CreateNewItem (pdoc, IDM_RECT, IDM_RED, TRUE);
    *lplpecddoc = (LPECDDOCUMENT)pdoc;

    return ECD_OK;

 }

 int     FAR     PASCAL SrvrCreateFromTemplate (lpecdsrvr, lhdoc, lpclassname,
 LHDOCUMENT    lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPSTR         lptemplatename;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

     PDOC    pdoc;

     PROBE_BUSY(bBusy);

     if(!(pdoc = CreateDocFromFile ((PSRVR)lpecdsrvr, lptemplatename, lhdoc)))
         return ECD_ERROR_MEMORY;

     ChangeDocName (pdoc, (LPSTR)lptemplatename);
     *lplpecddoc = (LPECDDOCUMENT)pdoc;
     return ECD_OK;

 }

 int     FAR     PASCAL SrvrEdit (lpecdsrvr, lhdoc, lpclassname, lpdocname, lp
 LHDOCUMENT    lhdoc;
 LPECDSERVER   lpecdsrvr;
 LPSTR         lpclassname;
 LPSTR         lpdocname;
 LPECDDOCUMENT  FAR *lplpecddoc;
 {

    PDOC pdoc;

    PROBE_BUSY(bBusy);

    // errors are not taken care properly

    if (!(pdoc = CreateNewDoc ((PSRVR)lpecdsrvr, lhdoc, lpdocname)))
         return ECD_ERROR_MEMORY;

    *lplpecddoc = (LPECDDOCUMENT)pdoc;

    return ECD_OK;


 }

 int     FAR     PASCAL SrvrExit (lpecdsrvr)
 LPECDSERVER   lpecdsrvr;
 {

     // Server lib is calling us to exit.
     // Let us hide the main window.
     // But let us not delete the window.
     PSRVR   psrvr;

     PROBE_BUSY(bBusy);

     psrvr = (PSRVR)lpecdsrvr;

     ShowWindow (psrvr->hwnd, FALSE);
     EcdRevokeServer (psrvr->lhsrvr);
     return ECD_OK;



 }

 // doucment functions.

 PDOC    InitDoc (hwnd, lhdoc)
 HWND        hwnd;
 LHDOCUMENT  lhdoc;
 {
     HANDLE      hdoc = NULL;
     PDOC        pdoc = NULL;
     char        buf[128];
     PSRVR       psrvr;



     hdoc = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (DOC));

     if (hdoc == NULL || (pdoc = (PDOC) LocalLock (hdoc)) == NULL)
         goto errRtn;

     pdoc->hdoc = hdoc;
     pdoc->hwnd = hwnd;        // corresponding main window

     psrvr = (PSRVR)GetWindowLong (GetParent (hwnd), 0);
     GetWindowText (hwnd, (LPSTR)buf, 128);
     if (lhdoc == NULL){
         if (EcdRegisterDocument (psrvr->lhsrvr, (LPSTR)buf, (LPECDDOCUMENT)pd
             (LHDOCUMENT FAR *)&pdoc->lhdoc) != ECD_OK)
             goto errRtn;
     } else
         pdoc->lhdoc = lhdoc;

     pdoc->aName = GlobalAddAtom ((LPSTR)buf);
     SetWindowLong (hwnd, 0, (LONG)pdoc);

     pdoc->ecddoc.lpvtbl = &docVTbl;

     // set the anchor point for children
     pdoc->ptAnchor.x = 0;
     pdoc->ptAnchor.y = 0;

     return pdoc;

 errRtn:

     if (pdoc)
         LocalUnlock (hdoc);

     if (hdoc)
         LocalFree;

     return (PDOC)NULL;

 }


 int FAR PASCAL  DocSave (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {

     PROBE_BUSY(bBusy);
     // not yet implemented
     return ECD_OK;


 }

 void DeleteDoc (pdoc)
 PDOC    pdoc;
 {
     LHDOCUMENT   lhdoc;

 #ifdef TEST
     EcdRevokeDocument ((LHDOCUMENT)pdoc);

 #else
     lhdoc = pdoc->lhdoc;
     pdoc->lhdoc = NULL;
     if (lhdoc) {
         ShowWindow (pdoc->hwnd, FALSE);
         EcdRevokeDocument (lhdoc);
     }
 #endif

 }


 int FAR PASCAL  DocClose (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {
     PDOC    pdoc;

     PROBE_BUSY(bBusy);
     pdoc = (PDOC)lpecddoc;

     SendDocChangeMsg (pdoc, ECD_CLOSED);
     DeleteDoc (pdoc);
     return ECD_OK;

 }

 int FAR PASCAL DocSetHostNames(lpecddoc, lpclientName, lpdocName)
 LPECDDOCUMENT    lpecddoc;
 LPSTR            lpclientName;
 LPSTR            lpdocName;
 {


     PDOC    pdoc;
     char    buf[200];
     int     len;
     HWND    hwnd;

     PROBE_BUSY(bBusy);

     // Do something to show that the titiel are chaning
     pdoc = (PDOC)lpecddoc;
     hwnd = pdoc->hwnd;

     SetWindowText (hwnd, lpdocName);;

     hwnd = GetParent (hwnd);
     lstrcpy ((LPSTR)buf, lpclientName);
     lstrcat ((LPSTR)buf, (LPSTR)":");
     lstrcat ((LPSTR)buf, (LPSTR)"Sample Server Application");
     len = lstrlen ((LPSTR)buf);
     SetWindowText (hwnd, (LPSTR)buf);

     return ECD_OK;

 }
 int FAR PASCAL DocSetDocDimensions(lpecddoc, lprc)
 LPECDDOCUMENT   lpecddoc;
 LPRECT  lprc;
 {
     PROBE_BUSY(bBusy);
     return ECD_OK;


 }

 int FAR PASCAL  DocRelease (lpecddoc)
 LPECDDOCUMENT    lpecddoc;
 {

     // !!! what is this supposed to do?
     // Revoke document calls DocRelease.

     PDOC    pdoc;
     HANDLE  hdoc;
     HWND    hwnd;


     PROBE_BUSY(bBusy);

     pdoc = (PDOC)lpecddoc;
     GlobalDeleteAtom (pdoc->aName);
     hwnd = pdoc->hwnd;
     LocalUnlock (hdoc = pdoc->hdoc);
     LocalFree (hdoc);
     DestroyWindow(hwnd);
     return TRUE;        // return something

 }

 int ChangeDocName (pdoc, lpname)
 PDOC    pdoc;
 LPSTR   lpname;
 {

     GlobalDeleteAtom (pdoc->aName);
     pdoc->aName = GlobalAddAtom (lpname);
     SetWindowText (pdoc->hwnd, lpname);
     return TRUE;        // return something

 }


 int FAR PASCAL  DocGetObject (lpecddoc, lpitemname, lplpecdobject, lpecdclien
 LPECDDOCUMENT       lpecddoc;
 LPSTR               lpitemname;
 LPECDOBJECT FAR *   lplpecdobject;
 LPECDCLIENT         lpecdclient;
 {
     PDOC    pdoc;
     HWND    hwnd;
     ATOM    aName;
     PITEM   pitem;


     PROBE_BUSY(bBusy);

     pdoc  = (PDOC)lpecddoc;
     aName = GlobalFindAtom (lpitemname);
     hwnd = GetWindow ((hwnd = pdoc->hwnd), GW_CHILD);

     // go thru all the child window list and find the window which is
     // matching the given item name.

     while (hwnd){

        // !!! We are trying to match the doc item with any item
        // OK only if there is only one item in a doc. Otherwise
        // we will be in troubles. Should work without any problems.
        // for embedded objects.

         pitem = (PITEM)GetWindowLong (hwnd, 0);

         // Alias the null with the very first item
         if (pitem->aName == aName || pitem->aName == NULL || aName == NULL)
             goto rtn;

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }
     // we did not find the item we wanted. So, create one

     // create a window with empty native data.

     if (CreateNewItem (pdoc, IDM_RECT, IDM_RED, FALSE)) {
         // newly created window is always the first child
         pitem = (PITEM)GetWindowLong (GetWindow (pdoc->hwnd, GW_CHILD), 0);
         BringWindowToTop (pitem->hwnd);
     } else
         return ECD_ERROR_MEMORY;
 rtn:
     pitem->aName = GlobalAddAtom (lpitemname);
     // If the item is not null, then do not show the window.
     *lplpecdobject = (LPECDOBJECT)pitem;
     pitem->lpecdclient = lpecdclient;
     return ECD_OK;

 }


 // item related routines

 void SetNewItemName (pitem)
 PITEM   pitem;
 {
     char    buf[3];

     lstrcpy ((LPSTR)pitem->name, (LPSTR)"Shape #");


     if (cShapes++ > 100)
         cShapes = 1;

     buf[0] = (char)((cShapes / 10)  + (int)'0');
     buf[1] = (char)((cShapes % 10)  + (int)'0');
     buf[2] = 0;

     lstrcat ((LPSTR)pitem->name, (LPSTR)buf);
     pitem->aName = GlobalAddAtom ((LPSTR)pitem->name);
 }

 void SetItemName (pitem, lpname)
 PITEM   pitem;
 LPSTR   lpname;
 {
     pitem->aName = GlobalAddAtom (lpname);
     lstrcpy ((LPSTR)pitem->name, lpname);
 }

 void CutCopyItem (hwnd)
 HWND    hwnd;
 {
     PITEM       pitem;

     if (OpenClipboard (hwnd)){

         EmptyClipboard ();

         // firt set the clipboard

         pitem = (PITEM) GetWindowLong (GetWindow(
                 GetWindow (hwnd, GW_CHILD), GW_CHILD), 0);

         // Check for null handles from the render routines.
         SetClipboardData (CF_METAFILEPICT, GetPicture (pitem));
         SetClipboardData (CF_BITMAP, GetBitmap (pitem));
         SetClipboardData (cfNative, GetNative (pitem));
         SetClipboardData (cfLink, GetLink (pitem));
         SetClipboardData (cfOwnerLink, GetLink (pitem));
         CloseClipboard ();
     }


 }

 HANDLE  GetNative (pitem)
 PITEM   pitem;
 {


     LPSTR       lpsrc;
     LPSTR       lplink = NULL;
     HANDLE      hlink = NULL;
     int         i;



     hlink = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, sizeof (ITEM));
     if (hlink== NULL || (lplink = (LPSTR)GlobalLock (hlink)) == NULL)
         goto errRtn;

     lpsrc = (LPSTR)pitem;
     for (i = 0; i <  sizeof(ITEM); i++)
         *lplink++ = *lpsrc++;

     GlobalUnlock (hlink);
     return hlink;

 errRtn:
     if (lplink)
         GlobalUnlock (hlink);

     if (hlink)
         GlobalFree (hlink);

 }

 HANDLE  GetLink (pitem)
 PITEM   pitem;
 {

     char        buf[128];
     LPSTR       lpsrc;
     LPSTR       lplink = NULL;
     HANDLE      hlink = NULL;
     int         len;
     int         i;

     // make the link
     lstrcpy ((LPSTR)buf, (LPSTR)"Shapes");
     len = lstrlen ((LPSTR)buf) + 1;
     len += GetWindowText (GetParent (pitem->hwnd), (LPSTR)buf + len , 128 - l
     len += GlobalGetAtomName (pitem->aName, (LPSTR)buf + len, 128 - len) + 1;
     buf[len++] = 0;       // throw in another null at the end.


     hlink = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, len);
     if (hlink== NULL || (lplink = (LPSTR)GlobalLock (hlink)) == NULL)
         goto errRtn;

     lpsrc = (LPSTR)buf;
     for (i = 0; i <  len; i++)
         *lplink++ = *lpsrc++;

     GlobalUnlock (hlink);

     return hlink;
 errRtn:
     if (lplink)
         GlobalUnlock (hlink);

     GlobalFree (hlink);
     return NULL;
 }

 HANDLE     GetPicture (pitem)
 PITEM       pitem;
 {

     LPMETAFILEPICT  lppict = NULL;
     HANDLE          hpict = NULL;
     HANDLE          hMF = NULL;
     HANDLE          hdc;
     RECT            rc;
     HPEN            hpen;
     HPEN            holdpen;
     int             mm;


     // Now set the bitmap data.

     hdc = CreateMetaFile(NULL);

     GetClientRect (pitem->hwnd, (LPRECT)&rc);

     // paint directly into the bitmap
     SelectObject (hdc, hbrColor [ pitem->cmdColor - IDM_RED]);
     PatBlt (hdc, 0,0, rc.right, rc.bottom, WHITENESS);
     SetWindowOrg (hdc, 0, 0);
     SetWindowExt (hdc, rc.right, rc.bottom);


     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdc, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }

     hMF = CloseMetaFile (hdc);

     if(!(hpict = GlobalAlloc (GMEM_DDESHARE, sizeof (METAFILEPICT))))
         goto errRtn;

     if ((lppict = (LPMETAFILEPICT)GlobalLock (hpict)) == NULL)
         goto errRtn;

     lppict->mm = MM_ANISOTROPIC;
     lppict->hMF = hMF;


     hdc = GetDC (pitem->hwnd);
     mm = SetMapMode(hdc, MM_HIMETRIC);
     DPtoLP(hdc, (LPPOINT)&rc, 2);
     SetMapMode(hdc, mm);
     ReleaseDC (pitem->hwnd, hdc);

     lppict->xExt =  rc.right - rc.left;
     lppict->yExt =  rc.top - rc.bottom;
     GlobalUnlock (hpict);
     return hpict;

 errRtn:
     if (lppict)
         GlobalUnlock (hpict);

     if (hpict)
         GlobalFree (hpict);

     if (hMF)
         DeleteMetaFile (hMF);
     return NULL;

 }


 HBITMAP     GetBitmap (pitem)
 PITEM       pitem;
 {

     HDC         hdc;
     HDC         hdcmem;
     RECT        rc;
     HBITMAP     hbitmap;
     HBITMAP     holdbitmap;
     HPEN        hpen;
     HPEN        holdpen;


     // Now set the bitmap data.

     hdc = GetDC (pitem->hwnd);
     hdcmem = CreateCompatibleDC (hdc);
     GetClientRect (pitem->hwnd, (LPRECT)&rc);
     hbitmap = CreateCompatibleBitmap (hdc, rc.right - rc.left, rc.bottom - rc
     holdbitmap = SelectObject (hdcmem, hbitmap);

     // paimt directly into the bitmap
     SelectObject (hdcmem, hbrColor [ pitem->cmdColor - IDM_RED]);
     PatBlt (hdcmem, 0,0, rc.right, rc.bottom, WHITENESS);

     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdcmem, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdcmem, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdcmem, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdcmem, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdcmem, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdcmem, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdcmem, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }



     hbitmap = SelectObject (hdcmem, holdbitmap);
     hpen = SelectObject (hdcmem, holdpen);
     DeleteObject (hpen);
     DeleteDC (hdcmem);
     ReleaseDC (pitem->hwnd, hdc);
     return hbitmap;

 }

 PITEM   CreateNewItem (pdoc, cmdShape, cmdColor, bVisible)
 PDOC    pdoc;
 int     cmdShape;
 int     cmdColor;
 BOOL    bVisible;
 {

     RECT        rc;
     HANDLE      hitem = NULL;
     PITEM       pitem = NULL;
     HWND        hwnd;



     GetClientRect (pdoc->hwnd, (LPRECT)&rc);

     hwnd = CreateWindow(
         "ItemClass",
         "Item",

         WS_DLGFRAME| WS_CHILD | WS_CLIPSIBLINGS |
                     (bVisible ? WS_VISIBLE : 0),
         pdoc->ptAnchor.x,
         pdoc->ptAnchor.y,
         (rc.right - rc.left) >> 1,
         (rc.bottom - rc.top)>> 1,
         pdoc->hwnd,
         NULL,
         hInst,
         NULL
     );


     if (!hwnd)
         return (FALSE);

     pdoc->ptAnchor.x += 20;
     pdoc->ptAnchor.y += 20;


     // Now create the item info;
     hitem = LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof (ITEM));

     if (hitem == NULL || ((pitem = (PITEM)LocalLock (hitem)) == NULL))
         goto  errRtn;

     pitem->cmdShape = cmdShape;;
     pitem->cmdColor = cmdColor;
     pitem->hitem    = hitem;
     pitem->aName    = NULL;
     pitem->hwnd     = hwnd;
     pitem->ecdobject.lpvtbl = &itemVTbl;

     pitem->width    = (rc.right - rc.left) >> 1;
     pitem->height   = (rc.bottom - rc.top) >> 1;

     SetWindowLong (hwnd, 0, (LONG)pitem);
     return pitem;

  errRtn:
     if (pitem)
         LocalUnlock (hitem);

     if (hitem)
         LocalFree (hitem);

     return (PITEM)NULL;

 }

 int FAR PASCAL  ItemOpen (lpecdobject)
 LPECDOBJECT     lpecdobject;
 {

     // !!! This routine should activate the app
     // and prepare it ready for the editing. Activation
     // should bring on to the top and restore


     PITEM   pitem;
     HWND    hwnd;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;
     BringWindowToTop (pitem->hwnd);
     BringWindowToTop (GetParent (pitem->hwnd));
     SetActiveWindow ((hwnd = GetParent (GetParent (pitem->hwnd))));
     SendMessage (hwnd, WM_SYSCOMMAND, SC_RESTORE, 0L);
     return ECD_OK;


 }


 int FAR PASCAL  ItemDelete (lpecdobject)
 LPECDOBJECT     lpecdobject;
 {

     PITEM   pitem;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;
     if (--pitem->ref)
         return ECD_OK;

     if (IsWindow(pitem->hwnd))
         DestroyWindow (pitem->hwnd);
     return ECD_OK;
 }


 int FAR PASCAL  ItemGetData (lpecdobject, cfFormat, lphandle)
 LPECDOBJECT     lpecdobject;
 WORD            cfFormat;
 LPHANDLE        lphandle;
 {

     PITEM   pitem;

     // PROBE_BUSY(bBusy);

     // asking data for emtyp object.
     pitem = (PITEM)lpecdobject;

     if (pitem->cmdShape  == NULL||
         pitem->cmdColor == NULL)
         return ECD_ERROR_MEMORY;

     if (cfFormat == cfNative){

         if (!(*lphandle = GetNative (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }


     if (cfFormat == CF_BITMAP){

         if (!(*lphandle = (HANDLE)GetBitmap (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }

     if (cfFormat == CF_METAFILEPICT){

         if (!(*lphandle = GetPicture (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }

     if (cfFormat == cfLink || cfFormat == cfOwnerLink){

         if (!(*lphandle = GetLink (pitem)))
             return ECD_ERROR_MEMORY;

         return ECD_OK;
     }
     return ECD_ERROR_MEMORY;          // this is actually unknow format.

 }


 int FAR PASCAL   ItemSetTargetDevice (lpecdobject, hdata)
 LPECDOBJECT     lpecdobject;
 HANDLE          hdata;
 {
     LPSTR   lpdata;

     lpdata = (LPSTR)GlobalLock (hdata);
     // Print the lpdata here.
     GlobalUnlock (hdata);
     GlobalFree (hdata);
     return ECD_OK;

 }

 int FAR PASCAL  ItemSetData (lpecdobject, cfFormat, hdata)
 LPECDOBJECT     lpecdobject;
 WORD            cfFormat;
 HANDLE          hdata;
 {

     LPITEM   lpitem;
     PITEM    pitem;

     PROBE_BUSY(bBusy);
     pitem = (PITEM)lpecdobject;

     if (cfFormat != cfNative)
         return ECD_ERROR_MEMORY;


     lpitem = (LPITEM)GlobalLock (hdata);
     if (lpitem){
         pitem->cmdShape = lpitem->cmdShape;
         pitem->cmdColor = lpitem->cmdColor;
         SetItemName (pitem, (LPSTR)pitem->name);
         // This is not necessary.
         ShowWindow (pitem->hwnd, TRUE);
         InvalidateRect (pitem->hwnd, (LPRECT)NULL, TRUE);
         GlobalUnlock (hdata);
     }

     GlobalFree (hdata);
     return ECD_OK;
 }

 ECDCLIPFORMAT   FAR PASCAL ItemEnumFormats (lpecdobject, cfFormat)
 LPECDOBJECT     lpecdobject;
 ECDCLIPFORMAT   cfFormat;
 {
     if (cfFormat == 0)
         return cfLink;

     if (cfFormat == cfLink)
         return cfOwnerLink;

     if (cfFormat == cfOwnerLink)
         return CF_BITMAP;

     if (cfFormat == CF_BITMAP)
         return CF_METAFILEPICT;

     if (cfFormat == CF_METAFILEPICT)
         return cfNative;

     //if (cfFormat == cfNative)
     //    return NULL;

     return NULL;
 }

 BOOL DestroyItem (hwnd)
 HWND    hwnd;
 {
     PITEM   pitem;
     HANDLE  hitem;


     pitem = (PITEM)GetWindowLong (hwnd, 0);
     if (pitem->aName)
         GlobalDeleteAtom (pitem->aName);

     LocalUnlock (hitem = pitem->hitem);
     LocalFree (hitem);
     return TRUE;        // return something

 }

 void    PaintItem (hwnd)
 HWND    hwnd;
 {

     HDC             hdc;
     PITEM           pitem;
     RECT            rc;
     PAINTSTRUCT     ptSt;
     HPEN            hpen;
     HPEN            holdpen;


     BeginPaint (hwnd, (LPPAINTSTRUCT)&ptSt);
     hdc = GetDC (hwnd);

     // Do not paint anything for the whole document item
     // For document item the name is null.

     pitem = (PITEM)GetWindowLong (hwnd, 0);

     GetClientRect (hwnd, (LPRECT)&rc);
     PatBlt (hdc, 0,0, rc.right, rc.bottom, WHITENESS);
     SelectObject (hdc, hbrColor [ pitem->cmdColor - IDM_RED]);
     hpen = CreatePen (PS_SOLID, 9, 0x00808080);
     holdpen = SelectObject (hdc, hpen);

     switch (pitem->cmdShape){
         case IDM_ROUNDRECT:
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

         case IDM_RECT:
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
             break;

         case IDM_HALLOWROUNDRECT:
             SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
             RoundRect (hdc, rc.left, rc.top, rc.right, rc.bottom,
                     (rc.right - rc.left) >> 2, (rc.bottom - rc.top) >> 2);
             break;

     }

     hpen = SelectObject (hdc, holdpen);
     DeleteObject (hpen);

     ReleaseDC (hwnd, hdc);
     EndPaint (hwnd, (LPPAINTSTRUCT)&ptSt);
 }



 void    SendSrvrChangeMsg (psrvr, options)
 PSRVR   psrvr;
 WORD    options;
 {

     HWND    hwnd;

     // if we are releasing the document, do not do anything
     if (psrvr->lhsrvr == NULL)
         return;

     hwnd = GetWindow (psrvr->hwnd, GW_CHILD);
     while (hwnd){
         SendDocChangeMsg ((PDOC)GetWindowLong (hwnd, 0), options);
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);

     }

 }

 void    SendDocRenameMsg (psrvr, options)
 PSRVR   psrvr;
 WORD    options;
 {

     HWND    hwnd;
     PITEM   pitem;
     PDOC    pdoc;
     char    buf[128];

     // if we are releasing the document, do not do anything
     if (psrvr->lhsrvr == NULL)
         return;

     hwnd = GetWindow (psrvr->hwnd, GW_CHILD);
     pdoc = (PDOC)GetWindowLong (hwnd, 0);

     // if we are releasing the document, do not do anything
     if (pdoc->lhdoc == NULL)
         return;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);

     while (hwnd){
         pitem = (PITEM)GetWindowLong (hwnd, 0);
         // Sending rename to obe item is sufficient
         if (pitem->lpecdclient){
             (*pitem->lpecdclient->lpvtbl->CallBack) (pitem->lpecdclient, opti
                     (LPECDOBJECT)pitem);

             return;
         }
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

     // reregister the document if there are no callbacks.
     GetWindowText (pdoc->hwnd, (LPSTR)buf, 128);
     DeleteDoc (pdoc);
     CreateDocFromFile (psrvr, (LPSTR)buf, NULL);
     return;
 }

 void    SendDocChangeMsg (pdoc, options)
 PDOC    pdoc;
 WORD    options;
 {

     HWND    hwnd;

     // if we are releasing the document, do not do anything
     if (pdoc->lhdoc == NULL)
         return;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);
     while (hwnd){
         SendItemChangeMsg ((PITEM)GetWindowLong (hwnd, 0), options);
         hwnd = GetWindow (hwnd, GW_HWNDNEXT);

     }

 }


 void    SendItemChangeMsg (pitem, options)
 PITEM   pitem;
 WORD    options;
 {

     if (pitem->lpecdclient)
         (*pitem->lpecdclient->lpvtbl->CallBack) (pitem->lpecdclient, options,
                 (LPECDOBJECT)pitem);
 }


 SHAPES.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\MISHAPES\SHAPES.C

 #define SERVERONLY
 #include "windows.h"
 #include "ecd.h"
 #include "shapes.h"
 #include <string.h>


 char FileName[128];
 char PathName[128];
 char OpenName[128];
 char DefPath[128];
 char DefSpec[13] = "*.shax104";
 char DefExt[] = ".txt";
 char str[255];

 RECT    dragRect;
 POINT   dragPt;
 HWND    hwndMain;
 BOOL    fCapture = FALSE;

 HBRUSH  hbrColor [5];

 char    *pcolors [5]  ={"RED",
                         "GREEN",
                         "BLUE",
                         "BLACK",
                         "YELLOW"
                        };
 char    *pshapes [4] = {
                         ":RECTANGLE",
                         ":ROUNDRECT"
                         ":HOLLOWRECT",
                         ":HOLLOWROUNDRECT"
                        };


 WORD        cfLink;
 WORD        cfOwnerLink;
 WORD        cfNative;
 WORD        cShapes = 0;
 BOOL        bBusy   = FALSE;


 HANDLE hInst;
 HANDLE hAccTable;


 //////////////////////////////////////////////////////////////////////////
 //
 // Right thing to do is to wait till the termination came from the client sid
 // This is lot more cleaner.
 //
 // (c) Copyright Microsoft Corp. 1990 - All Rights Reserved
 //
 /////////////////////////////////////////////////////////////////////////


 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 LPSTR   lpCmdLine;
 int nCmdShow;
 {
     MSG msg;



     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);




     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     if (!InitServer (hwndMain, hInstance))
         return FALSE;

     if (!ProcessCmdLine (hwndMain, lpCmdLine))
         return FALSE;

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwndMain, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }

     DeleteInstance ();
     return (msg.wParam);
 }



 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 4;
     wc.cbWndExtra = 4;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "InitMenu";

     wc.lpszClassName = "SampleClass";
     wc.lpfnWndProc = MainWndProc;

     if (!RegisterClass(&wc))
         return NULL;


     wc.hIcon   = NULL;
     wc.hCursor = NULL;
     wc.lpszMenuName  = NULL;
     wc.lpszClassName = "DocClass";
     wc.lpfnWndProc   = DocWndProc;

     if (!RegisterClass(&wc))
         return NULL;



     wc.hIcon   = NULL;
     wc.hCursor = NULL;
     wc.lpszMenuName = NULL;
     wc.lpszClassName = "ItemClass";
     wc.lpfnWndProc   = ItemWndProc;

     if (!RegisterClass(&wc))
         return NULL;

 }



 BOOL InitInstance(hInstance, nCmdShow)
 HANDLE          hInstance;
 int             nCmdShow;
 {

     // initialse the proc tables.
     InitVTbls ();

     hbrColor [0] = CreateSolidBrush (0x000000ff);
     hbrColor [1] = CreateSolidBrush (0x0000ff00);
     hbrColor [2] = CreateSolidBrush (0x00ff0000);
     hbrColor [3] = CreateSolidBrush (0x00000000);
     hbrColor [4] = CreateSolidBrush (0x00ff00ff);

     // register clipboard formats.
     cfLink      = RegisterClipboardFormat("ObjectLink");
     cfOwnerLink = RegisterClipboardFormat("OwnerLink");
     cfNative    = RegisterClipboardFormat("Native");


     hInst = hInstance;
     hAccTable = LoadAccelerators(hInst, "SampleAcc");

     hwndMain = CreateWindow(
         "SampleClass",
         "Sample miServer Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );


     if (!hwndMain)
         return (FALSE);

     ShowWindow(hwndMain, nCmdShow);
     UpdateWindow(hwndMain);
     return (TRUE);

 }

 void    DeleteInstance ()
 {

     // Free the proc table instances.
     FreeVTbls ();

     DeleteObject (hbrColor [0]);
     DeleteObject (hbrColor [1]);
     DeleteObject (hbrColor [2]);
     DeleteObject (hbrColor [3]);
     DeleteObject (hbrColor [4]);

 }

 // main window or server related routiens

 long FAR PASCAL MainWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpOpenDlg, lpSaveDlg;

     int     Return;
     PITEM   pitem;
     PDOC    pdoc;



     switch (message) {
         case WM_COMMAND:
             switch (wParam) {


                 case IDM_NEWITEM:
                     pdoc = (PDOC)GetWindowLong (GetWindow (hwnd, GW_CHILD), 0
                     pitem = CreateNewItem  (pdoc, IDM_RECT, IDM_RED, TRUE);
                     SetNewItemName (pitem);
                     BringWindowToTop (pitem->hwnd);
                     break;

                 case IDM_RED:
                 case IDM_GREEN:
                 case IDM_BLUE:
                 case IDM_BLACK:
                 case IDM_YELLOW:

                     pitem = (PITEM)GetWindowLong (
                             GetWindow (GetWindow(hwnd, GW_CHILD), GW_CHILD),
                     pitem->cmdColor = wParam;
                     InvalidateRect (pitem->hwnd, (LPRECT)NULL,  TRUE);
                     // make sure that we have the right bits on the screen
                     UpdateWindow (pitem->hwnd);
                     SendItemChangeMsg (pitem, ECD_CHANGED);
                     break;


                 case IDM_RECT:
                 case IDM_ROUNDRECT:
                 case IDM_HALLOWRECT:
                 case IDM_HALLOWROUNDRECT:

                     pitem = (PITEM)GetWindowLong (
                             GetWindow (GetWindow(hwnd, GW_CHILD), GW_CHILD),
                     pitem->cmdShape = wParam;
                     InvalidateRect (pitem->hwnd, (LPRECT)NULL,  TRUE);
                     UpdateWindow (pitem->hwnd);
                     SendItemChangeMsg (pitem, ECD_CHANGED);
                     break;

                 case IDM_NEW:

                     // create another document widnwo.
                     pdoc = CreateNewDoc ((PSRVR)GetWindowLong (hwnd, 0), NULL
                     if (pdoc == NULL)
                         break;
                     pitem = CreateNewItem (pdoc, IDM_RECT, IDM_RED, TRUE);
                     SetNewItemName (pitem);
                     BringWindowToTop (pdoc->hwnd);
                     break;


                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hwnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 case IDM_OPEN:
                     /* Call OpenDlg() to get the filename */

                     lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);
                     Return = DialogBox(hInst, "Open", hwnd, lpOpenDlg);
                     FreeProcInstance(lpOpenDlg);

                     if (!CreateDocFromFile ((PSRVR)GetWindowLong (hwnd, 0), (
                         MessageBox (
                               hwndMain,
                               "reading from file failed",
                               "Server Sample Sample Application",
                                MB_OK);


                     break;

                 case IDM_SAVE:

                     lpSaveDlg = MakeProcInstance((FARPROC) SaveDlg, hInst);
                     Return = DialogBox(hInst, "Save", hwnd, lpSaveDlg);
                     FreeProcInstance(lpSaveDlg);

                     SaveDocIntoFile (pdoc = (PDOC) (GetWindowLong (GetWindow
                         (LPSTR)OpenName);

                     // send message for save
                     SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_SA
                     SendDocRenameMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_REN
                     break;


                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "Server Sample Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;



                 case IDM_EXIT:
                     SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_CL
                     DeleteServer ((PSRVR)GetWindowLong (hwnd, 0));
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:

                     CutCopyItem (hwnd);
                     break;

                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "Server Sample  Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "server Sample  Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SIZE:
             if (wParam == SIZENORMAL)
                 ReSizeAllDocs (hwnd, LOWORD (lParam), HIWORD (lParam));

             break;

         case WM_CLOSE:
             SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_CLOSED);
             DeleteServer ((PSRVR)GetWindowLong (hwnd, 0));
             break;

         case WM_DESTROY:
             PostQuitMessage (0);
             break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }





 HANDLE FAR PASCAL SaveDlg (hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDOK:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);

                     AddExt(OpenName, DefExt);
                     EndDialog(hDlg, TRUE);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             SetDlgItemText(hDlg, IDC_EDIT, (LPSTR)"shape1.sha");
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }




 HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
     HANDLE hFile=1;     /* Temp value for return */

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDC_LISTBOX:
                     switch (HIWORD(lParam)) {

                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
                             if (DlgDirSelect(hDlg, str, IDC_LISTBOX))
                                 strcat(str, DefSpec);

                             SetDlgItemText(hDlg, IDC_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 IDC_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));
                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                     }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
                     if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) OpenName);
                         if (str[0])
                             strcpy(DefPath, str);
                         ChangeDefExt(DefExt, DefSpec);
                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     if (!OpenName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                     }

                     AddExt(OpenName, DefExt);

                     /* The routine to open the file would go here, and the */
                     /* file handle would be returned instead of NULL.
                     EndDialog(hDlg, hFile);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }



 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* To ensure that the listing is made for a subdir. of
      * current drive dir...
      */
     if (!strchr (DefPath, ':'))
   DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* Remove the '..' character from path if it exists, since this
      * will make DlgDirList move us up an additional level in the tree
      * when UpdateListBox() is called again.
      */
     if (strstr (DefPath, ".."))
   DefPath[0] = '\0';

     SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
 }


 void ChangeDefExt(Ext, Name)
 PSTR Ext, Name;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr)
         if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
             strcpy(Ext, pTptr);
 }


 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;
     char  cTmp;

     lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {
         lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     lstrcpy(lpDestFileName, lpTmp + 1);
     cTmp = *(lpTmp + 1);
     lstrcpy(lpDestPath, lpSrcFileName);
      *(lpTmp + 1) = cTmp;
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }



 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }


 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

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


 void   DrawDragRect (hwnd)
 HWND    hwnd;
 {

         HDC hdc;

         hdc = GetDC(hwnd);
         InvertRect (hdc, (LPRECT)&dragRect);
         ReleaseDC (hwnd, hdc);

 }

 void    ReSizeAllDocs (hwndSrvr, width, height)
 HWND    hwndSrvr;
 int     width;
 int     height;
 {
     HWND    hwnd;
     RECT    rc;


     hwnd = GetWindow (hwndSrvr, GW_CHILD);
     while (hwnd){
         GetWindowRect (hwnd, (LPRECT)&rc);
         ScreenToClient (hwndSrvr, (LPPOINT)&rc);
         MoveWindow (hwnd, rc.left, rc.top,
             width , height, TRUE);

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

 }
 void    ReSizeAllItems (hwndDoc, width, height)
 HWND    hwndDoc;
 int     width;
 int     height;
 {
     HWND    hwnd;
     RECT    rc;


     hwnd = GetWindow (hwndDoc, GW_CHILD);
     while (hwnd){
         GetWindowRect (hwnd, (LPRECT)&rc);
         ScreenToClient (hwndDoc, (LPPOINT)&rc);
         MoveWindow (hwnd, rc.left, rc.top,
             width >> 1, height >> 1, TRUE);

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

 }

 long FAR PASCAL ItemWndProc (hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
         POINT   pt;
         HWND    hwndParent;


     switch (message) {
         case WM_PAINT:
             PaintItem (hwnd);
             break;


         case WM_SIZE:
             break;

         case WM_DESTROY:
             DestroyItem (hwnd);
             break;

         case WM_RBUTTONDOWN:


             hwndParent = GetParent (hwnd);
             GetWindowRect (hwnd, (LPRECT) &dragRect);
             ScreenToClient (hwndParent, (LPPOINT)&dragRect);
             ScreenToClient (hwndParent, (LPPOINT)&dragRect.right);

             DrawDragRect (hwndParent);

             dragPt.x = LOWORD(lParam);
             dragPt.y = HIWORD(lParam);

             ClientToScreen (hwnd, (LPPOINT)&dragPt);
             ScreenToClient (hwndParent, (LPPOINT)&dragPt);

             SetCapture (hwnd);
             fCapture = TRUE;
             break;

         case WM_MOUSEMOVE:
             if (!fCapture)
                 break;

             hwndParent = GetParent (hwnd);
             DrawDragRect (hwndParent);
             pt.x = LOWORD(lParam);
             pt.y = HIWORD(lParam);

             ClientToScreen (hwnd, (LPPOINT)&pt);
             ScreenToClient (hwndParent, (LPPOINT)&pt);

             OffsetRect ((LPRECT)&dragRect, pt.x - dragPt.x,
                                         pt.y - dragPt.y);

             dragPt.x = pt.x;
             dragPt.y = pt.y;


             DrawDragRect (hwndParent);
             break;


         case WM_RBUTTONUP:
             if (!fCapture)
                 return TRUE;

             hwndParent = GetParent (hwnd);
             fCapture = FALSE;
             ReleaseCapture ();
             DrawDragRect (hwndParent);

             MoveWindow (hwnd, dragRect.left, dragRect.top,
                         dragRect.right - dragRect.left,
                         dragRect.bottom - dragRect.top, TRUE);

              // fall thru

         case WM_LBUTTONDOWN:
              BringWindowToTop (hwnd);
              break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }


 BOOL    SaveDocIntoFile (pdoc, lpstr)
 PDOC    pdoc;
 LPSTR   lpstr;
 {


     HWND    hwnd;
     int     fh;
     PITEM   pitem;


     if ((fh =_lcreat (lpstr, 0)) <= 0)
         return FALSE;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);

     while (hwnd) {
         pitem = (PITEM) GetWindowLong (hwnd, 0);
         if (!pitem->aName)
             SetNewItemName (pitem);

         if (_lwrite (fh, (LPSTR)pitem, sizeof (ITEM)) <= 0)
             break;

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }
     _lclose (fh);

     SetWindowText (pdoc->hwnd, (LPSTR)lpstr);
     return TRUE;
 }


 PDOC    CreateDocFromFile (psrvr, lpstr, lhdoc)
 PSRVR       psrvr;
 LPSTR       lpstr;
 LHDOCUMENT  lhdoc;
 {

     int     fh;
     ITEM    item;
     PITEM   pitem;
     PDOC    pdoc;


     if ((fh =_lopen (lpstr, OF_READ)) <= 0)
         return FALSE;

     if (!(pdoc = CreateNewDoc (psrvr, lhdoc, lpstr)))
         return FALSE;

     cShapes = 0;
     while (TRUE) {
         if (_lread (fh, (LPSTR)&item, sizeof (ITEM)) <= 0)
             break;

         pitem = CreateNewItem (pdoc, item.cmdShape, item.cmdColor, TRUE);
         SetItemName (pitem, (LPSTR)item.name);
         cShapes++;
     }
     _lclose (fh);


     return pdoc;
 }

 // doc related routines

 PDOC    CreateNewDoc (psrvr, lhdoc, lptitle)
 PSRVR   psrvr;
 LONG    lhdoc;
 LPSTR   lptitle;
 {

     RECT        rc;
     HMENU       hMenu;
     HWND        hwnd;

     hwnd = psrvr->hwnd;

     // first set the menu.
     hMenu = GetMenu (hwnd);
     DestroyMenu (hMenu);

     hMenu = LoadMenu (hInst, (LPSTR)"SampleMenu");
     SetMenu (hwnd, hMenu);
     DrawMenuBar (hwnd);

     GetClientRect (hwnd, (LPRECT)&rc);
     if (IsIconic (psrvr->hwnd)){
         // create some reasonale height/wdith for satisfying the
         // data request in iconic mode
         rc.right = GetSystemMetrics (SM_CXSCREEN) >> 1;
         rc.bottom   = GetSystemMetrics (SM_CYSCREEN) >> 1;
     }
     InflateRect ((LPRECT)&rc, -5, -5);

     hwnd = CreateWindow(
         "DocClass",
         "New",
         WS_SYSMENU | WS_CAPTION | WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,

         rc.left,
         rc.top,
         (rc.right - rc.left),
         (rc.bottom - rc.top),
         psrvr->hwnd,
         NULL,
         hInst,
         NULL
     );

     SetWindowText (hwnd, lptitle);
     return InitDoc (hwnd, lhdoc);
 }

 long FAR PASCAL DocWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     HWND    hwndChild;
     HWND    hwndParent;
     HMENU   hMenu;

     switch (message) {

         case WM_SIZE:
             if (wParam == SIZENORMAL)
                 ReSizeAllItems (hwnd, LOWORD (lParam), HIWORD (lParam));
             break;

         case WM_CLOSE:
             SendDocChangeMsg ((PDOC)GetWindowLong (hwnd, 0), ECD_CLOSED);
             DeleteDoc ((PDOC)GetWindowLong (hwnd, 0));
             break;

         case WM_DESTROY:

             hwndParent = GetParent (hwnd);
             hwndChild = GetWindow(hwndParent, GW_CHILD);

             if (GetWindow (hwndChild, GW_HWNDNEXT))
                 break;          // some more doc windows.

             // first set the menu.
             hMenu  = GetMenu (hwndMain);
             DestroyMenu (hMenu);

             // we do not ahve any more doc windows.
             hMenu = LoadMenu (hInst, (LPSTR)"InitMenu");
             SetMenu (hwndMain, hMenu);
             DrawMenuBar (hwndMain);
             break;



         case WM_LBUTTONDOWN:
             BringWindowToTop (hwnd);
             break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }


 SHAPES.C
 CD-ROM Disc Path:   \SAMPCODE\OLE\SHAPES\SHAPES.C

 #define SERVERONLY
 #include "windows.h"
 #include "ecd.h"
 #include "shapes.h"
 #include <string.h>


 char FileName[128];
 char PathName[128];
 char OpenName[128];
 char DefPath[128];
 char DefSpec[13] = "*.shax104";
 char DefExt[] = ".txt";
 char str[255];

 RECT    dragRect;
 POINT   dragPt;
 HWND    hwndMain;
 BOOL    fCapture = FALSE;

 HBRUSH  hbrColor [5];

 char    *pcolors [5]  ={"RED",
                         "GREEN",
                         "BLUE",
                         "BLACK",
                         "YELLOW"
                        };
 char    *pshapes [4] = {
                         ":RECTANGLE",
                         ":ROUNDRECT"
                         ":HOLLOWRECT",
                         ":HOLLOWROUNDRECT"
                        };


 WORD        cfLink;
 WORD        cfOwnerLink;
 WORD        cfNative;
 WORD        cShapes = 0;
 BOOL        bBusy   = FALSE;


 HANDLE hInst;
 HANDLE hAccTable;


 //////////////////////////////////////////////////////////////////////////
 //
 // Right thing to do is to wait till the termination came from the client sid
 // This is lot more cleaner.
 //
 // (c) Copyright Microsoft Corp. 1990 - All Rights Reserved
 //
 /////////////////////////////////////////////////////////////////////////


 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 LPSTR   lpCmdLine;
 int nCmdShow;
 {
     MSG msg;



     if (!hPrevInstance)
         if (!InitApplication(hInstance))
             return (FALSE);




     if (!InitInstance(hInstance, nCmdShow))
         return (FALSE);

     if (!InitServer (hwndMain, hInstance))
         return FALSE;

     if (!ProcessCmdLine (hwndMain, lpCmdLine))
         return FALSE;

     while (GetMessage(&msg, NULL, NULL, NULL)) {

     /* Only translate message if it is not an accelerator message */

         if (!TranslateAccelerator(hwndMain, hAccTable, &msg)) {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }

     DeleteInstance ();
     return (msg.wParam);
 }



 BOOL InitApplication(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS  wc;

     wc.style = NULL;
     wc.lpfnWndProc = MainWndProc;
     wc.cbClsExtra = 4;
     wc.cbWndExtra = 4;
     wc.hInstance = hInstance;
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName =  "InitMenu";

     wc.lpszClassName = "SampleClass";
     wc.lpfnWndProc = MainWndProc;

     if (!RegisterClass(&wc))
         return NULL;


     wc.hIcon   = NULL;
     wc.hCursor = NULL;
     wc.lpszMenuName  = NULL;
     wc.lpszClassName = "DocClass";
     wc.lpfnWndProc   = DocWndProc;

     if (!RegisterClass(&wc))
         return NULL;



     wc.hIcon   = NULL;
     wc.hCursor = NULL;
     wc.lpszMenuName = NULL;
     wc.lpszClassName = "ItemClass";
     wc.lpfnWndProc   = ItemWndProc;

     if (!RegisterClass(&wc))
         return NULL;

 }



 BOOL InitInstance(hInstance, nCmdShow)
 HANDLE          hInstance;
 int             nCmdShow;
 {

     // initialse the proc tables.
     InitVTbls ();

     hbrColor [0] = CreateSolidBrush (0x000000ff);
     hbrColor [1] = CreateSolidBrush (0x0000ff00);
     hbrColor [2] = CreateSolidBrush (0x00ff0000);
     hbrColor [3] = CreateSolidBrush (0x00000000);
     hbrColor [4] = CreateSolidBrush (0x00ff00ff);

     // register clipboard formats.
     cfLink      = RegisterClipboardFormat("ObjectLink");
     cfOwnerLink = RegisterClipboardFormat("OwnerLink");
     cfNative    = RegisterClipboardFormat("Native");


     hInst = hInstance;
     hAccTable = LoadAccelerators(hInst, "SampleAcc");

     hwndMain = CreateWindow(
         "SampleClass",
         "Sample Server Application",
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         NULL,
         NULL,
         hInstance,
         NULL
     );


     if (!hwndMain)
         return (FALSE);

     ShowWindow(hwndMain, nCmdShow);
     UpdateWindow(hwndMain);
     return (TRUE);

 }

 void    DeleteInstance ()
 {

     // Free the proc table instances.
     FreeVTbls ();

     DeleteObject (hbrColor [0]);
     DeleteObject (hbrColor [1]);
     DeleteObject (hbrColor [2]);
     DeleteObject (hbrColor [3]);
     DeleteObject (hbrColor [4]);

 }

 // main window or server related routiens

 long FAR PASCAL MainWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpProcAbout, lpOpenDlg, lpSaveDlg;

     int     Return;
     PITEM   pitem;
     PDOC    pdoc;



     switch (message) {
         case WM_COMMAND:
             switch (wParam) {


                 case IDM_NEWITEM:
                     pdoc = (PDOC)GetWindowLong (GetWindow (hwnd, GW_CHILD), 0
                     pitem = CreateNewItem  (pdoc, IDM_RECT, IDM_RED, TRUE);
                     SetNewItemName (pitem);
                     BringWindowToTop (pitem->hwnd);
                     break;

                 case IDM_RED:
                 case IDM_GREEN:
                 case IDM_BLUE:
                 case IDM_BLACK:
                 case IDM_YELLOW:

                     pitem = (PITEM)GetWindowLong (
                             GetWindow (GetWindow(hwnd, GW_CHILD), GW_CHILD),
                     pitem->cmdColor = wParam;
                     InvalidateRect (pitem->hwnd, (LPRECT)NULL,  TRUE);
                     // make sure that we have the right bits on the screen
                     UpdateWindow (pitem->hwnd);
                     SendItemChangeMsg (pitem, ECD_CHANGED);
                     break;


                 case IDM_RECT:
                 case IDM_ROUNDRECT:
                 case IDM_HALLOWRECT:
                 case IDM_HALLOWROUNDRECT:

                     pitem = (PITEM)GetWindowLong (
                             GetWindow (GetWindow(hwnd, GW_CHILD), GW_CHILD),
                     pitem->cmdShape = wParam;
                     InvalidateRect (pitem->hwnd, (LPRECT)NULL,  TRUE);
                     UpdateWindow (pitem->hwnd);
                     SendItemChangeMsg (pitem, ECD_CHANGED);
                     break;

                 case IDM_NEW:

                     // create another document widnwo.
                     pdoc = CreateNewDoc ((PSRVR)GetWindowLong (hwnd, 0), NULL
                     if (pdoc == NULL)
                         break;
                     pitem = CreateNewItem (pdoc, IDM_RECT, IDM_RED, TRUE);
                     SetNewItemName (pitem);
                     BringWindowToTop (pdoc->hwnd);
                     break;


                 case IDM_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hwnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 case IDM_OPEN:
                     /* Call OpenDlg() to get the filename */

                     lpOpenDlg = MakeProcInstance((FARPROC) OpenDlg, hInst);
                     Return = DialogBox(hInst, "Open", hwnd, lpOpenDlg);
                     FreeProcInstance(lpOpenDlg);

                     if (!CreateDocFromFile ((PSRVR)GetWindowLong (hwnd, 0), (
                         MessageBox (
                               hwndMain,
                               "reading from file failed",
                               "Server Sample Sample Application",
                                MB_OK);


                     break;

                 case IDM_SAVE:

                     lpSaveDlg = MakeProcInstance((FARPROC) SaveDlg, hInst);
                     Return = DialogBox(hInst, "Save", hwnd, lpSaveDlg);
                     FreeProcInstance(lpSaveDlg);

                     SaveDocIntoFile (pdoc = (PDOC) (GetWindowLong (GetWindow
                         (LPSTR)OpenName);

                     // send message for save
                     SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_SA
                     SendDocRenameMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_REN
                     break;


                 case IDM_SAVEAS:
                 case IDM_PRINT:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "Server Sample Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;



                 case IDM_EXIT:
                     SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_CL
                     DeleteServer ((PSRVR)GetWindowLong (hwnd, 0));
                     break;

                 /* edit menu commands */

                 case IDM_UNDO:
                 case IDM_CUT:
                 case IDM_COPY:

                     CutCopyItem (hwnd);
                     break;

                 case IDM_PASTE:
                 case IDM_CLEAR:
                     MessageBox (
                           GetFocus(),
                           "Command not implemented",
                           "Server Sample  Sample Application",
                           MB_ICONASTERISK | MB_OK);
                     break;

                 case IDC_EDIT:
                     if (HIWORD (lParam) == EN_ERRSPACE) {
                         MessageBox (
                               GetFocus ()
                             , "Out of memory."
                             , "server Sample  Sample Application"
                             , MB_ICONHAND | MB_OK
                         );
                     }
                     break;

             }
             break;

         case WM_SIZE:
             if (wParam == SIZENORMAL)
                 ReSizeAllDocs (hwnd, LOWORD (lParam), HIWORD (lParam));

             break;

         case WM_CLOSE:
             SendSrvrChangeMsg ((PSRVR)GetWindowLong (hwnd, 0), ECD_CLOSED);
             DeleteServer ((PSRVR)GetWindowLong (hwnd, 0));
             break;

         case WM_DESTROY:
             PostQuitMessage (0);
             break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }





 HANDLE FAR PASCAL SaveDlg (hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDOK:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);

                     AddExt(OpenName, DefExt);
                     EndDialog(hDlg, TRUE);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             SetDlgItemText(hDlg, IDC_EDIT, (LPSTR)"shape1.sha");
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }




 HANDLE FAR PASCAL OpenDlg(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
     HANDLE hFile=1;     /* Temp value for return */

     switch (message) {
         case WM_COMMAND:
             switch (wParam) {

                 case IDC_LISTBOX:
                     switch (HIWORD(lParam)) {

                         case LBN_SELCHANGE:
                             /* If item is a directory name, append "*.*" */
                             if (DlgDirSelect(hDlg, str, IDC_LISTBOX))
                                 strcat(str, DefSpec);

                             SetDlgItemText(hDlg, IDC_EDIT, str);
                             SendDlgItemMessage(hDlg,
                                 IDC_EDIT,
                                 EM_SETSEL,
                                 NULL,
                                 MAKELONG(0, 0x7fff));
                             break;

                         case LBN_DBLCLK:
                             goto openfile;
                     }
                     return (TRUE);

                 case IDOK:
 openfile:
                     GetDlgItemText(hDlg, IDC_EDIT, OpenName, 128);
                     if (strchr(OpenName, '*') || strchr(OpenName, '?')) {
                         SeparateFile(hDlg, (LPSTR) str, (LPSTR) DefSpec,
                             (LPSTR) OpenName);
                         if (str[0])
                             strcpy(DefPath, str);
                         ChangeDefExt(DefExt, DefSpec);
                         UpdateListBox(hDlg);
                         return (TRUE);
                     }

                     if (!OpenName[0]) {
                         MessageBox(hDlg, "No filename specified.",
                             NULL, MB_OK | MB_ICONHAND);
                         return (TRUE);
                     }

                     AddExt(OpenName, DefExt);

                     /* The routine to open the file would go here, and the */
                     /* file handle would be returned instead of NULL.
                     EndDialog(hDlg, hFile);
                     return (TRUE);

                 case IDCANCEL:
                     EndDialog(hDlg, NULL);
                     return (FALSE);
             }
             break;

         case WM_INITDIALOG:                        /* message: initialize
             UpdateListBox(hDlg);
             SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
             SendDlgItemMessage(hDlg,               /* dialog handle      */
                 IDC_EDIT,                          /* where to send message
                 EM_SETSEL,                         /* select characters
                 NULL,                              /* additional information
                 MAKELONG(0, 0x7fff));              /* entire contents      */
             SetFocus(GetDlgItem(hDlg, IDC_EDIT));
             return (FALSE); /* Indicates the focus is set to a control */
     }
     return FALSE;
 }



 void UpdateListBox(hDlg)
 HWND hDlg;
 {
     strcpy(str, DefPath);
     strcat(str, DefSpec);
     DlgDirList(hDlg, str, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* To ensure that the listing is made for a subdir. of
      * current drive dir...
      */
     if (!strchr (DefPath, ':'))
   DlgDirList(hDlg, DefSpec, IDC_LISTBOX, IDC_PATH, 0x4010);

     /* Remove the '..' character from path if it exists, since this
      * will make DlgDirList move us up an additional level in the tree
      * when UpdateListBox() is called again.
      */
     if (strstr (DefPath, ".."))
   DefPath[0] = '\0';

     SetDlgItemText(hDlg, IDC_EDIT, DefSpec);
 }


 void ChangeDefExt(Ext, Name)
 PSTR Ext, Name;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr)
         if (!strchr(pTptr, '*') && !strchr(pTptr, '?'))
             strcpy(Ext, pTptr);
 }


 void SeparateFile(hDlg, lpDestPath, lpDestFileName, lpSrcFileName)
 HWND hDlg;
 LPSTR lpDestPath, lpDestFileName, lpSrcFileName;
 {
     LPSTR lpTmp;
     char  cTmp;

     lpTmp = lpSrcFileName + (long) lstrlen(lpSrcFileName);
     while (*lpTmp != ':' && *lpTmp != '\\' && lpTmp > lpSrcFileName)
         lpTmp = AnsiPrev(lpSrcFileName, lpTmp);
     if (*lpTmp != ':' && *lpTmp != '\\') {
         lstrcpy(lpDestFileName, lpSrcFileName);
         lpDestPath[0] = 0;
         return;
     }
     lstrcpy(lpDestFileName, lpTmp + 1);
     cTmp = *(lpTmp + 1);
     lstrcpy(lpDestPath, lpSrcFileName);
      *(lpTmp + 1) = cTmp;
     lpDestPath[(lpTmp - lpSrcFileName) + 1] = 0;
 }



 void AddExt(Name, Ext)
 PSTR Name, Ext;
 {
     PSTR pTptr;

     pTptr = Name;
     while (*pTptr && *pTptr != '.')
         pTptr++;
     if (*pTptr != '.')
         strcat(Name, Ext);
 }


 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             return (TRUE);

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


 void   DrawDragRect (hwnd)
 HWND    hwnd;
 {

         HDC hdc;

         hdc = GetDC(hwnd);
         InvertRect (hdc, (LPRECT)&dragRect);
         ReleaseDC (hwnd, hdc);

 }

 void    ReSizeAllDocs (hwndSrvr, width, height)
 HWND    hwndSrvr;
 int     width;
 int     height;
 {
     HWND    hwnd;
     RECT    rc;


     hwnd = GetWindow (hwndSrvr, GW_CHILD);
     while (hwnd){
         GetWindowRect (hwnd, (LPRECT)&rc);
         ScreenToClient (hwndSrvr, (LPPOINT)&rc);
         MoveWindow (hwnd, rc.left, rc.top,
             width , height, TRUE);

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

 }
 void    ReSizeAllItems (hwndDoc, width, height)
 HWND    hwndDoc;
 int     width;
 int     height;
 {
     HWND    hwnd;
     RECT    rc;


     hwnd = GetWindow (hwndDoc, GW_CHILD);
     while (hwnd){
         GetWindowRect (hwnd, (LPRECT)&rc);
         ScreenToClient (hwndDoc, (LPPOINT)&rc);
         MoveWindow (hwnd, rc.left, rc.top,
             width >> 1, height >> 1, TRUE);

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }

 }

 long FAR PASCAL ItemWndProc (hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
         POINT   pt;
         HWND    hwndParent;


     switch (message) {
         case WM_PAINT:
             PaintItem (hwnd);
             break;


         case WM_SIZE:
             break;

         case WM_DESTROY:
             DestroyItem (hwnd);
             break;

         case WM_RBUTTONDOWN:


             hwndParent = GetParent (hwnd);
             GetWindowRect (hwnd, (LPRECT) &dragRect);
             ScreenToClient (hwndParent, (LPPOINT)&dragRect);
             ScreenToClient (hwndParent, (LPPOINT)&dragRect.right);

             DrawDragRect (hwndParent);

             dragPt.x = LOWORD(lParam);
             dragPt.y = HIWORD(lParam);

             ClientToScreen (hwnd, (LPPOINT)&dragPt);
             ScreenToClient (hwndParent, (LPPOINT)&dragPt);

             SetCapture (hwnd);
             fCapture = TRUE;
             break;

         case WM_MOUSEMOVE:
             if (!fCapture)
                 break;

             hwndParent = GetParent (hwnd);
             DrawDragRect (hwndParent);
             pt.x = LOWORD(lParam);
             pt.y = HIWORD(lParam);

             ClientToScreen (hwnd, (LPPOINT)&pt);
             ScreenToClient (hwndParent, (LPPOINT)&pt);

             OffsetRect ((LPRECT)&dragRect, pt.x - dragPt.x,
                                         pt.y - dragPt.y);

             dragPt.x = pt.x;
             dragPt.y = pt.y;


             DrawDragRect (hwndParent);
             break;


         case WM_RBUTTONUP:
             if (!fCapture)
                 return TRUE;

             hwndParent = GetParent (hwnd);
             fCapture = FALSE;
             ReleaseCapture ();
             DrawDragRect (hwndParent);

             MoveWindow (hwnd, dragRect.left, dragRect.top,
                         dragRect.right - dragRect.left,
                         dragRect.bottom - dragRect.top, TRUE);

              // fall thru

         case WM_LBUTTONDOWN:
              BringWindowToTop (hwnd);
              break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }


 BOOL    SaveDocIntoFile (pdoc, lpstr)
 PDOC    pdoc;
 LPSTR   lpstr;
 {


     HWND    hwnd;
     int     fh;
     PITEM   pitem;


     if ((fh =_lcreat (lpstr, 0)) <= 0)
         return FALSE;

     hwnd = GetWindow (pdoc->hwnd, GW_CHILD);

     while (hwnd) {
         pitem = (PITEM) GetWindowLong (hwnd, 0);
         if (!pitem->aName)
             SetNewItemName (pitem);

         if (_lwrite (fh, (LPSTR)pitem, sizeof (ITEM)) <= 0)
             break;

         hwnd = GetWindow (hwnd, GW_HWNDNEXT);
     }
     _lclose (fh);

     SetWindowText (pdoc->hwnd, (LPSTR)lpstr);
     return TRUE;
 }


 PDOC    CreateDocFromFile (psrvr, lpstr, lhdoc)
 PSRVR       psrvr;
 LPSTR       lpstr;
 LHDOCUMENT  lhdoc;
 {

     int     fh;
     ITEM    item;
     PITEM   pitem;
     PDOC    pdoc;


     if ((fh =_lopen (lpstr, OF_READ)) <= 0)
         return FALSE;

     if (!(pdoc = CreateNewDoc (psrvr, lhdoc, lpstr)))
         return FALSE;

     cShapes = 0;
     while (TRUE) {
         if (_lread (fh, (LPSTR)&item, sizeof (ITEM)) <= 0)
             break;

         pitem = CreateNewItem (pdoc, item.cmdShape, item.cmdColor, TRUE);
         SetItemName (pitem, (LPSTR)item.name);
         cShapes++;
     }
     _lclose (fh);


     return pdoc;
 }

 // doc related routines

 PDOC    CreateNewDoc (psrvr, lhdoc, lptitle)
 PSRVR   psrvr;
 LONG    lhdoc;
 LPSTR   lptitle;
 {

     RECT        rc;
     HMENU       hMenu;
     HWND        hwnd;

     hwnd = psrvr->hwnd;

     // first set the menu.
     hMenu = GetMenu (hwnd);
     DestroyMenu (hMenu);

     hMenu = LoadMenu (hInst, (LPSTR)"SampleMenu");
     SetMenu (hwnd, hMenu);
     DrawMenuBar (hwnd);

     GetClientRect (hwnd, (LPRECT)&rc);
     if (IsIconic (psrvr->hwnd)){
         // create some reasonale height/wdith for satisfying the
         // data request in iconic mode
         rc.right = GetSystemMetrics (SM_CXSCREEN) >> 1;
         rc.bottom   = GetSystemMetrics (SM_CYSCREEN) >> 1;
     }
     InflateRect ((LPRECT)&rc, -5, -5);

     hwnd = CreateWindow(
         "DocClass",
         "New",
         WS_SYSMENU | WS_CAPTION | WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,

         rc.left,
         rc.top,
         (rc.right - rc.left),
         (rc.bottom - rc.top),
         psrvr->hwnd,
         NULL,
         hInst,
         NULL
     );

     SetWindowText (hwnd, lptitle);
     return InitDoc (hwnd, lhdoc);
 }

 long FAR PASCAL DocWndProc(hwnd, message, wParam, lParam)
 HWND hwnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     HWND    hwndChild;
     HWND    hwndParent;
     HMENU   hMenu;

     switch (message) {

         case WM_SIZE:
             if (wParam == SIZENORMAL)
                 ReSizeAllItems (hwnd, LOWORD (lParam), HIWORD (lParam));
             break;

         case WM_CLOSE:
             SendDocChangeMsg ((PDOC)GetWindowLong (hwnd, 0), ECD_CLOSED);
             DeleteDoc ((PDOC)GetWindowLong (hwnd, 0));
             break;

         case WM_DESTROY:

             hwndParent = GetParent (hwnd);
             hwndChild = GetWindow(hwndParent, GW_CHILD);

             if (GetWindow (hwndChild, GW_HWNDNEXT))
                 break;          // some more doc windows.

             // first set the menu.
             hMenu  = GetMenu (hwndMain);
             DestroyMenu (hMenu);

             // we do not ahve any more doc windows.
             hMenu = LoadMenu (hInst, (LPSTR)"InitMenu");
             SetMenu (hwndMain, hMenu);
             DrawMenuBar (hwndMain);
             break;



         case WM_LBUTTONDOWN:
             BringWindowToTop (hwnd);
             break;

         default:
             return (DefWindowProc(hwnd, message, wParam, lParam));
     }
     return (NULL);
 }




 Microsoft Windows Sample `C' Source Code


 ACSRESRC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\ACSRESRC.C

 /*
  * Name: acsresrc.c
  * Function (s) demonstrated in this program: AccessResource (), FindResource
  *                                           SizeofResource ().
  * Description  :
  *         FindResource is used first to locate and identify the resource
  *         item.  SizeofResource is used to determine how many bytes need
  *         to be read to obtain the resource item, and finally
  *         AccessResource () is used to get the handle and set the file
  *         pointer to the beginning of the selected resource.  AccessResource
  *         opens the file (resource) as a result, so it must be explicitely
  *         closed.  In this case, "It works!" is displayed in a MessageBox ()
  *         upon successful completion, "It failed" displays if unsuccessful.
  * Additional Comments: Note that _lclose () must be used to close the file
  *         (resource).
  */

 #include <windows.h>
 #include "acsresrc.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 int     FAR PASCAL _lclose (int);
 int     FAR PASCAL _lread (HANDLE, LPSTR, short);

 static char  szBuffer[8];
 static int  ErrorCheck;
 static char  szResName [] = "HotStuff";

 int    PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      nCmdShow;
   {
   static char  szAppName [] = "Resources";
   HWND       hWnd;
   WNDCLASS   wndclass;
   MSG        msg;
   HMENU      hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hMenu = LoadMenu (hInstance, "ResMenu");

   hWnd = CreateWindow (szAppName, "AccessResource",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, hMenu, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned  iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   static HANDLE hInstance, hResource;
   int  hFile;
   char  szStuff[20], szSuccess[20];
   short sRes;

   switch (iMessage)
     {
     case WM_CREATE:
       hInstance = GetWindowWord (hWnd, GWW_HINSTANCE);
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_EXECUTE:
 /* FindResource is used first to locate and identify the resource
         item.  SizeofResource is used to determine how many bytes need
         to be read to obtain the resource item, and finally
         AccessResource () is used to get the handle and set the file
         pointer to the beginning of the selected resource.  AccessResource ()
         opens the file (resource) as a result, so it must be explicitely
         closed.
      */
           hResource = FindResource (hInstance, "HotStuff", RT_RCDATA);
           sRes = SizeofResource (hInstance, hResource);
           hFile = AccessResource (hInstance, hResource);
           ErrorCheck = _lread (hFile, (LPSTR)szStuff, sRes);
           ErrorCheck = _lclose (hFile);
           if (hFile < 1)
             {
             ErrorCheck = sprintf (szStuff, "It failed");
             ErrorCheck = sprintf (szSuccess, "Error");
             }
     else
             ErrorCheck = sprintf (szSuccess, "Item read");
           MessageBox (GetFocus (), szStuff, szSuccess, MB_OK);
         }
         break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ADDATOM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\ADDATOM.C

 /*
  * Function (s) demonstrated in this program: AddAtom
  * Compiler version: MSC v5.10
  * Description: Program adds a character string to the atom table and creates
  *              a new atom that uniquely identifies the string.
  */

 #include <windows.h>
 #include "addatom.h"

 int     sprintf (LPSTR, LPSTR, int);
 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
   {
   static char   szAppName [] = "AddAtom";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hMenu = LoadMenu (hInstance, "OurMenu");
   hWnd = CreateWindow (szAppName, "AddAtom Demonstration",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT,  0,
                       NULL, hMenu, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   int  AtomMaxSize = 20;
   ATOM  lpIDForAtom;
   WORD ActualAtomSize;
   int  hToAtom;
   BOOL  bTableAdded;
   char  szBuff[20];

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == IDM_EXECUTE)
         {
         SetFocus (hWnd);
         lpIDForAtom = AddAtom ( (LPSTR)"Hello World");
         ActualAtomSize = GetAtomName (lpIDForAtom, (LPSTR)szBuff, AtomMaxSize
         MessageBox (GetFocus (), (LPSTR)szBuff, (LPSTR)"Atom added was...", M
         hToAtom = GetAtomHandle (lpIDForAtom);
         lpIDForAtom = DeleteAtom (lpIDForAtom);
         if (lpIDForAtom == NULL)
           MessageBox (GetFocus (), (LPSTR)"Success", (LPSTR)"Atom Deleted", M
         else
           MessageBox (GetFocus (), (LPSTR)"Failure", (LPSTR)"Atom not deleted
         }
       else
         return (DefWindowProc (hWnd, iMessage, wParam, lParam));
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ADDFONT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\ADDFONT.C

 /*
  * Name               : AddFont.c
  * Function(s) demonstrated in this program :
  *     AddFontResource (), RemoveFontResource (), SendMessage ().
  * Description        : AddFontResource loads an external file of fonts,
  *                      returning a short integer of fonts that have been
  *                      added.  SendMessage sends a WM_FONTCHANGE message
  *                      to notify other windows of the change.
  *                      RemoveFontResource is used to remove the resource
  *                      that was added.  The resource may be added multiple
  *                      times, and deleted once for every time it was added.
  *                      If you attempt to delete it furthermore, an error
  *                      message comes up indicating that the resource is not
  *                      available to delete.
  *
  * NOTE:                Script.fon is required to be in the same directory.
  *
  */

 #include <windows.h>
 #include "addfont.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 int     sprintf (PSTR, PSTR, int);

 static char  szBuffer[] = "script.fon";
 static int  ErrorCheck;
 static char  szResName [] = "ResMenu";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
   {
   static char   szAppName [] = "FontResources";
   HWND      hWnd;
   WNDCLASS  wndclass;
   MSG       msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName, "The Joy of FontResources",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, NULL, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   static HANDLE hInstance, hResource;
   int  hFile;
   char  szBuf[50];
   short  sRes;
   HMENU hMenu;
   switch (iMessage)
     {
     case WM_CREATE:
       hInstance = GetWindowWord (hWnd, GWW_HINSTANCE);
       hMenu = LoadMenu (hInstance, "ResMenu");
       SetMenu (hWnd, hMenu);
       DrawMenuBar (hWnd);
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_ADDFONT:
           ErrorCheck = AddFontResource ( (LPSTR)szBuffer);
           SendMessage (-1, WM_FONTCHANGE, 0, 0L);
           ErrorCheck = sprintf (szBuf, "%i", ErrorCheck);
           MessageBox (GetFocus (), szBuf, "Number of added Fonts", MB_OK);
           break;

         case IDM_REMOVEFONT:
           sRes = RemoveFontResource ( (LPSTR)szBuffer);
           if (sRes != NULL)
             {
             ErrorCheck = sprintf (szBuf, "%i:  indicating the FontResource wa
             MessageBox (GetFocus (), szBuf, "RemoveFontResource returns", MB_
             }
     else
             MessageBox (GetFocus (), "Problem removing Font!", "Error", MB_OK
           SendMessage (-1, WM_FONTCHANGE, 0, 0L);
     break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ADWIRE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ADWIRE.C

 /*
  *
  *   Function (s) demonstrated in this program:
  *        AdjustWindowRect ()
  *
  *   Compiler version:
  *        Microsoft C 5.1
  *
  *   Description:
  *        This function demonstrates the use of the AdjustWindowRect function
  *        It will compute the required size of the window rectangle based on
  *        the desired client-rectangle size.  The window rectangle will then
  *        passed to the CreateWindow function to create a Window whose client
  *        area is the desired size.
  *
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitCreateWindow (HANDLE, HANDLE, int);
 long  FAR PASCAL CreateWindowProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int  nCmdShow;
 {
   MSG msg;

   InitCreateWindow (hInstance, hPrevInstance, nCmdShow);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
   }
   exit (msg.wParam);
 }


 BOOL FAR PASCAL InitCreateWindow (hInstance, hPrevInstance, cmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 int  cmdShow;
 {
   WNDCLASS  wcCreateWindowClass;
   HWND  hWnd;

   wcCreateWindowClass.lpszClassName = (LPSTR) "CreateWindow";
   wcCreateWindowClass.hInstance     = hInstance;
   wcCreateWindowClass.lpfnWndProc   = CreateWindowProc;
   wcCreateWindowClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcCreateWindowClass.hIcon         = NULL;
   wcCreateWindowClass.lpszMenuName  = (LPSTR) NULL;
   wcCreateWindowClass.hbrBackground = GetStockObject (BLACK_BRUSH);
   wcCreateWindowClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcCreateWindowClass.cbClsExtra    = 0;
   wcCreateWindowClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcCreateWindowClass);

   hWnd = CreateWindow ( (LPSTR) "CreateWindow", (LPSTR) "AdjustWindowRect",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);         /* Display this window on the screen  *
   UpdateWindow (hWnd);                              /* Cause a paint message

   return TRUE;
 }


 long  FAR PASCAL CreateWindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned  message;
 WORD        wParam;
 LONG        lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintCreate (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return (DefWindowProc (hWnd, message, wParam, lParam));
     break;
   }
   return (0L);
 }


 PaintCreate (hWnd)  /*  The Paint Procedure  */
 HWND    hWnd;
 {
   PAINTSTRUCT  ps;
   HDC          hDC;
   BOOL         bMenu;
   long  lStyle;
   HANDLE       hOldBrush, hBrush;
   RECT         lpRect;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);

   hDC = ps.hdc;                                  /* Get the Display Context
   lStyle = WS_TILED;
   bMenu = 0;
   hBrush         = GetStockObject (BLACK_BRUSH);  /* Get a Black brush     */
   hOldBrush      = SelectObject (hDC, hBrush);   /* Select the new brush  */

   SetMapMode (hDC, MM_ANISOTROPIC);              /* Set the mapping mode  */
   SetWindowExt (hDC, 200, 200);           /* Set Extent of viewing area. */
   GetClientRect (hWnd, (LPRECT) & lpRect);     /* Get size of client area. */
   SetViewportExt (hDC, lpRect.right, lpRect.bottom); /* Set extent of viewpor
   AdjustWindowRect (&lpRect, lStyle, bMenu);
   TextOut (hDC, 10, 10,
       (LPSTR)"Smallest rectangle that will encompass the entire Window.",
       strlen ("Smallest rectangle that will encompass the entire Window."));

   ValidateRect (hWnd, (LPRECT) NULL);   /* Disable any more paint messages  *
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   SelectObject (hDC, hOldBrush);                /*  Replace the old brush  */

   return TRUE;
 }




 ADWIRE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\ADWIRE.C

 /*
  *
  *   Function (s) demonstrated in this program:
  *        AdjustWindowRect ()
  *
  *   Compiler version:
  *        Microsoft C 5.1
  *
  *   Description:
  *        This function demonstrates the use of the AdjustWindowRect function
  *        It will compute the required size of the window rectangle based on
  *        the desired client-rectangle size.  The window rectangle will then
  *        passed to the CreateWindow function to create a Window whose client
  *        area is the desired size.
  *
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitCreateWindow (HANDLE, HANDLE, int);
 long  FAR PASCAL CreateWindowProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int  nCmdShow;
 {
   MSG msg;

   InitCreateWindow (hInstance, hPrevInstance, nCmdShow);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
   }
   exit (msg.wParam);
 }


 BOOL FAR PASCAL InitCreateWindow (hInstance, hPrevInstance, cmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 int  cmdShow;
 {
   WNDCLASS  wcCreateWindowClass;
   HWND  hWnd;

   wcCreateWindowClass.lpszClassName = (LPSTR) "CreateWindow";
   wcCreateWindowClass.hInstance     = hInstance;
   wcCreateWindowClass.lpfnWndProc   = CreateWindowProc;
   wcCreateWindowClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcCreateWindowClass.hIcon         = NULL;
   wcCreateWindowClass.lpszMenuName  = (LPSTR) NULL;
   wcCreateWindowClass.hbrBackground = GetStockObject (BLACK_BRUSH);
   wcCreateWindowClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcCreateWindowClass.cbClsExtra    = 0;
   wcCreateWindowClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcCreateWindowClass);

   hWnd = CreateWindow ( (LPSTR) "CreateWindow", (LPSTR) "AdjustWindowRect",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);         /* Display this window on the screen  *
   UpdateWindow (hWnd);                              /* Cause a paint message

   return TRUE;
 }


 long  FAR PASCAL CreateWindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned  message;
 WORD        wParam;
 LONG        lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintCreate (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return (DefWindowProc (hWnd, message, wParam, lParam));
     break;
   }
   return (0L);
 }


 PaintCreate (hWnd)  /*  The Paint Procedure  */
 HWND    hWnd;
 {
   PAINTSTRUCT  ps;
   HDC          hDC;
   BOOL         bMenu;
   long  lStyle;
   HANDLE       hOldBrush, hBrush;
   RECT         lpRect;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);

   hDC = ps.hdc;                                  /* Get the Display Context
   lStyle = WS_TILED;
   bMenu = 0;
   hBrush         = GetStockObject (BLACK_BRUSH);  /* Get a Black brush     */
   hOldBrush      = SelectObject (hDC, hBrush);   /* Select the new brush  */

   SetMapMode (hDC, MM_ANISOTROPIC);              /* Set the mapping mode  */
   SetWindowExt (hDC, 200, 200);           /* Set Extent of viewing area. */
   GetClientRect (hWnd, (LPRECT) & lpRect);     /* Get size of client area. */
   SetViewportExt (hDC, lpRect.right, lpRect.bottom); /* Set extent of viewpor
   AdjustWindowRect (&lpRect, lStyle, bMenu);
   TextOut (hDC, 10, 10,
       (LPSTR)"Smallest rectangle that will encompass the entire Window.",
       strlen ("Smallest rectangle that will encompass the entire Window."));

   ValidateRect (hWnd, (LPRECT) NULL);   /* Disable any more paint messages  *
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   SelectObject (hDC, hOldBrush);                /*  Replace the old brush  */

   return TRUE;
 }




 ALLOCRES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\ALLOCRES.C

 /*
  * Name: allocres.c
  * Function (s) demonstrated : AllocResource (), FindResource (),
  *                             SizeofResource (), AccessResource ().
  * Windows version    : 2.03
  * Compiler version   : 5.1
  * Description        :
  *         FindResource is used first to locate and identify the resource
  *         item.  SizeofResource is used to determine how many bytes need
  *         to be read to obtain the resource item, AllocResource () is used
  *         to allocate memory for the resource, and finally AccessResource ()
  *         allows us to read the resource in directly.
  *
  */

 #include <windows.h>
 #include "AllocRes.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 int     FAR PASCAL _lclose (int);
 int     FAR PASCAL _lread (HANDLE, LPSTR, short);

 static char  szBuffer[8];
 static int  ErrorCheck;
 static char  szResName [] = "HotStuff";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
   {
   static char szAppName [] = "Resources";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG         msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName, "The Joy of Resources",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, NULL, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned  iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   static HANDLE hInstance, hResource, hGlobRes;
   int  hFile;
   char  far *szStuff, szSuccess[20];
   short  sRes;
   HMENU  hMenu;

   switch (iMessage)
     {
     case WM_CREATE:
       hInstance = GetWindowWord (hWnd, GWW_HINSTANCE);
       hMenu = LoadMenu (hInstance, "ResMenu");
       SetMenu (hWnd, hMenu);
       DrawMenuBar (hWnd);
       break;
     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_EXECUTE:
       /*  FindResource is used first to locate and identify the resource
        *  item.  SizeofResource is used to determine how many bytes need
        *  to be read to obtain the resource item, AllocResource () reserves
        *  the memory to store the resource and AccessResource () permits
        *  reading of the resource.
        */
           hResource = FindResource (hInstance, "HotStuff", RT_RCDATA);
           sRes = SizeofResource (hInstance, hResource);
           hGlobRes = AllocResource (hInstance, hResource, (DWORD)sRes);
           ErrorCheck = sprintf (szStuff, "%i", hGlobRes);
           MessageBox (GetFocus (), szStuff, "hGlobRes returns...", MB_OK);
           szStuff = GlobalLock (hGlobRes);
           hFile = AccessResource (hInstance, hResource);
           ErrorCheck = _lread (hFile, (LPSTR)szStuff, sRes);
           ErrorCheck = GlobalUnlock (hGlobRes);
           hGlobRes = GlobalFree (hGlobRes);
           ErrorCheck = _lclose (hFile);
           if (hFile < 1)
             {
             ErrorCheck = sprintf (szStuff, "It failed");
             ErrorCheck = sprintf (szSuccess, "Error");
             }
     else
             ErrorCheck = sprintf (szSuccess, "Item read");
           MessageBox (GetFocus (), szStuff, szSuccess, MB_OK);
           break;

         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ANSI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\ANSI.C

 /*
  *
  *   Function (s) demonstrated in this program:
  *        AnsiLower (LPSTR)
  *        AnsiUpper (LPSTR)
  *        AnsiToOem (LPSTR, LPSTR)
  *        AnsiNext (LPSTR)
  *        AnsiPrev (LPSTR, LPSTR)
  *        OemToAnsi (LPSTR, LPSTR)
  */

 #include <windows.h>
 #include <stdio.h>

 #define MAXSTRING 80

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  wndclass;
   MSG       msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = "ANSI";

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow ("ANSI",
                       "Ansi Functions",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC         hDC;
   HMENU       hMenu;
   TEXTMETRIC  tm;
   char  szAnsiBuff[MAXSTRING];
   char  szOemBuff[MAXSTRING];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Display", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hDC = GetDC (hWnd);
         GetTextMetrics (hDC, (LPTEXTMETRIC) & tm);
         sprintf (szAnsiBuff, "A Sample String: aBcDwXyZ ©«®²³º");
         TextOut (hDC, 1, tm.tmHeight * 1, (LPSTR)"ANSI Character Set", 18);
         TextOut (hDC, 1, tm.tmHeight * 2, (LPSTR)szAnsiBuff, 31);

         AnsiToOem ( (LPSTR)szAnsiBuff, (LPSTR)szOemBuff);
         TextOut (hDC, 1, tm.tmHeight * 4,
             (LPSTR)"ANSI Characters Converted to Nearest OEM Characters by An
             67);
         TextOut (hDC, 1, tm.tmHeight * 5, (LPSTR)szOemBuff, 31);

         OemToAnsi ( (LPSTR)szOemBuff, (LPSTR)szAnsiBuff);
         TextOut (hDC, 1, tm.tmHeight * 7,
             (LPSTR)"OEM Characters Converted to Nearest ANSI Characters by Oe
             67);
         TextOut (hDC, 1, tm.tmHeight * 8, (LPSTR)szAnsiBuff, 31);

   /* Convert original ANSI string to all lower case. */
         TextOut (hDC, 1, tm.tmHeight * 10,
             (LPSTR)"Original ANSI String Processed by AnsiLower ()", 46);
         TextOut (hDC, 1, tm.tmHeight * 11, AnsiLower ( (LPSTR)szAnsiBuff), 31

   /* Convert lower case ANSI string to all upper case. */
         TextOut (hDC, 1, tm.tmHeight * 13,
             (LPSTR)"Lower Case ANSI String Processed by AnsiUpper ()", 48);
         TextOut (hDC, 1, tm.tmHeight * 14, AnsiUpper ( (LPSTR)szAnsiBuff), 31

   /* Use AnsiNext () and AnsiPrev (). */
         TextOut (hDC, 1, tm.tmHeight * 16,
             (LPSTR)"Display String Starting at Next Char After Fifth Char Usi
             71);
         TextOut (hDC, 1, tm.tmHeight * 17, AnsiNext ( (LPSTR) & szAnsiBuff[4]
             26);

         TextOut (hDC, 1, tm.tmHeight * 19,
             (LPSTR)"Display String Starting at Char Previous to Fifth Char Us
             72);
         TextOut (hDC, 1, tm.tmHeight * 20, AnsiPrev ( (LPSTR)szAnsiBuff,
             (LPSTR) & szAnsiBuff[4]), 27);

         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ANSI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\ANSI.C

 /*
  *
  *   Function (s) demonstrated in this program:
  *        AnsiLower (LPSTR)
  *        AnsiUpper (LPSTR)
  *        AnsiToOem (LPSTR, LPSTR)
  *        AnsiNext (LPSTR)
  *        AnsiPrev (LPSTR, LPSTR)
  *        OemToAnsi (LPSTR, LPSTR)
  */

 #include <windows.h>
 #include <stdio.h>

 #define MAXSTRING 80

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  wndclass;
   MSG       msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = "ANSI";

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow ("ANSI",
                       "Ansi Functions",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC         hDC;
   HMENU       hMenu;
   TEXTMETRIC  tm;
   char  szAnsiBuff[MAXSTRING];
   char  szOemBuff[MAXSTRING];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Display", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hDC = GetDC (hWnd);
         GetTextMetrics (hDC, (LPTEXTMETRIC) & tm);
         sprintf (szAnsiBuff, "A Sample String: aBcDwXyZ ©«®²³º");
         TextOut (hDC, 1, tm.tmHeight * 1, (LPSTR)"ANSI Character Set", 18);
         TextOut (hDC, 1, tm.tmHeight * 2, (LPSTR)szAnsiBuff, 31);

         AnsiToOem ( (LPSTR)szAnsiBuff, (LPSTR)szOemBuff);
         TextOut (hDC, 1, tm.tmHeight * 4,
             (LPSTR)"ANSI Characters Converted to Nearest OEM Characters by An
             67);
         TextOut (hDC, 1, tm.tmHeight * 5, (LPSTR)szOemBuff, 31);

         OemToAnsi ( (LPSTR)szOemBuff, (LPSTR)szAnsiBuff);
         TextOut (hDC, 1, tm.tmHeight * 7,
             (LPSTR)"OEM Characters Converted to Nearest ANSI Characters by Oe
             67);
         TextOut (hDC, 1, tm.tmHeight * 8, (LPSTR)szAnsiBuff, 31);

   /* Convert original ANSI string to all lower case. */
         TextOut (hDC, 1, tm.tmHeight * 10,
             (LPSTR)"Original ANSI String Processed by AnsiLower ()", 46);
         TextOut (hDC, 1, tm.tmHeight * 11, AnsiLower ( (LPSTR)szAnsiBuff), 31

   /* Convert lower case ANSI string to all upper case. */
         TextOut (hDC, 1, tm.tmHeight * 13,
             (LPSTR)"Lower Case ANSI String Processed by AnsiUpper ()", 48);
         TextOut (hDC, 1, tm.tmHeight * 14, AnsiUpper ( (LPSTR)szAnsiBuff), 31

   /* Use AnsiNext () and AnsiPrev (). */
         TextOut (hDC, 1, tm.tmHeight * 16,
             (LPSTR)"Display String Starting at Next Char After Fifth Char Usi
             71);
         TextOut (hDC, 1, tm.tmHeight * 17, AnsiNext ( (LPSTR) & szAnsiBuff[4]
             26);

         TextOut (hDC, 1, tm.tmHeight * 19,
             (LPSTR)"Display String Starting at Char Previous to Fifth Char Us
             72);
         TextOut (hDC, 1, tm.tmHeight * 20, AnsiPrev ( (LPSTR)szAnsiBuff,
             (LPSTR) & szAnsiBuff[4]), 27);

         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 ANYPOPUP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\ANYPOPUP.C

 /*
  *   This program demonstrates the use of the AnyPopup () function.
  *   AnyPopup () determines if a popup window is present on the screen, even
  *   if hidden. AnyPop () is called in response to choosing the "AnyPopup?"
  *   menu option. To create a popup, choose the "Create Popup" menu option.
  *   This function can also be tested by bringing up another application
  *   which creates a popup window.
  */

 #include "windows.h"
 #include "anypopup.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);
 long    FAR PASCAL PopupProc (HWND, unsigned, WORD, LONG);

 HWND hPopup = NULL;   /* handle to the popup window */
 HANDLE hInst;

 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName      = (LPSTR)"anypopup";
   pHelloClass->lpszClassName     = (LPSTR)"AnyPopup";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"CHILD A";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc   = PopupProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit (hInstance);

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR)"AnyPopup", "AnyPopup ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_ANYPOPUP:
                 /* are there any  popup windows present in the system ? */
           if (AnyPopup ())  /* if yes, say so */
             MessageBox (NULL, (LPSTR)"there ARE popup windows present",
                        (LPSTR)"AnyPopup () says...", MB_OK);
           else
             MessageBox (NULL, (LPSTR)"there are NOT popup windows present",
                        (LPSTR)"AnyPopup () says...", MB_OK);
           break;

         case IDM_CREATEPOPUP:     /*  Create a popup Window  */
           hPopup = CreateWindow ( (LPSTR)"CHILD A",
                                   (LPSTR)"Child A (WS_POPUP)", WS_POPUP |
                                   WS_VISIBLE | WS_CAPTION | WS_CLIPSIBLINGS |
                                   WS_BORDER | WS_SYSMENU, 45, 60, 250, 200,
                                   hWnd, NULL, hInst, NULL);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }

 long    FAR PASCAL PopupProc (hChildAWnd, message, wParam, lParam)
 HWND      hChildAWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     default:
       return DefWindowProc (hChildAWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 APP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\JOURNAL\APP.C

 /*  APP.c
     Skeleton Application
     Windows Toolkit Version 2.00
     Copyright (c) Microsoft 1987
 */

 #include "windows.h"
 #include "APP.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[15];
 int MessageLength;
 HANDLE hInst;
 FARPROC lpprocAbout;

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!Init( hInstance ))
             return FALSE;
         }
     else {
         /* ONLY ONE INSTANCE */
         return FALSE;
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                         WS_OVERLAPPEDWINDOW,
                         400,               /*  x - ignored for tiled windows
                         0,                 /*  y - ignored for tiled windows
                         CW_USEDEFAULT,     /* cx - ignored for tiled windows
                         0,                 /* cy - ignored for tiled windows
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }
 /*
 */


 /* Procedure called when the application is loaded for the first time */
 BOOL Init( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pAPPClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pAPPClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pAPPClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pAPPClass->hIcon          = LoadIcon( hInstance, MAKEINTRESOURCE(APPICON)
     pAPPClass->lpszMenuName   = (LPSTR)szAppName;
     pAPPClass->lpszClassName  = (LPSTR)szAppName;
     pAPPClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pAPPClass->hInstance      = hInstance;
     pAPPClass->style          = CS_HREDRAW | CS_VREDRAW;
     pAPPClass->lpfnWndProc    = WndProc;

     if (!RegisterClass( (LPWNDCLASS)pAPPClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pAPPClass );
     return TRUE;        /* Initialization succeeded */
 }
 /*
 */


 APP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\MENUHELP\APP.C

 /*  APP.c
     Skeleton Application
     Windows Toolkit Version 2.00
     Copyright (c) Microsoft 1987
 */

 #include "windows.h"
 #include "APP.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[15];
 int MessageLength;
 HANDLE hInst;
 FARPROC lpprocAbout;

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!Init( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szMessage, 15 );
         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                         WS_OVERLAPPEDWINDOW,
                         400,               /*  x - ignored for tiled windows
                         0,                 /*  y - ignored for tiled windows
                         CW_USEDEFAULT,     /* cx - ignored for tiled windows
                         0,                 /* cy - ignored for tiled windows
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }
 /*
 */


 /* Procedure called when the application is loaded for the first time */
 BOOL Init( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pAPPClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pAPPClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pAPPClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pAPPClass->hIcon          = LoadIcon( hInstance, (LPSTR)szAppName );
     pAPPClass->lpszMenuName   = (LPSTR)szAppName;
     pAPPClass->lpszClassName  = (LPSTR)szAppName;
     pAPPClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pAPPClass->hInstance      = hInstance;
     pAPPClass->style          = CS_HREDRAW | CS_VREDRAW;
     pAPPClass->lpfnWndProc    = WndProc;

     if (!RegisterClass( (LPWNDCLASS)pAPPClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pAPPClass );
     return TRUE;        /* Initialization succeeded */
 }
 /*
 */


 APPCMD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\MENUHELP\APPCMD.C

 #include "windows.h"
 #include "APP.h"

 void APPCommand( HWND, WORD, LONG );


 void APPCommand( hWnd, wParam, lParam )
 HWND hWnd;
 WORD wParam;
 LONG lParam;
 {
         MessageBox ( hWnd, (LPSTR)"Item Selected!",
                            (LPSTR)"Menu", MB_OK );
         return;
 }


 APPPAINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\JOURNAL\APPPAINT.C

 #include "windows.h"
 #include "APP.h"

 extern char szMessage[];
 extern int MessageLength;

 void APPPaint( HWND, WORD, LONG );


 void APPPaint(  hWnd, wParam, lParam )
 HWND hWnd;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;
     RECT rRect;

     BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
 /*
     GetClientRect( hWnd, (LPRECT)&rRect );
     ScrollWindow( hWnd, 0, -rRect.bottom, (LPRECT)NULL, (LPRECT)NULL);
 */
     EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
 }
 /*
 */


 APPPAINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\MENUHELP\APPPAINT.C

 #include "windows.h"
 #include "APP.h"

 extern char szMessage[];
 extern int MessageLength;

 void APPPaint( HWND, WORD, LONG );


 void APPPaint(  hWnd, wParam, lParam )
 HWND hWnd;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
     TextOut( ps.hdc,
              (short)10,
              (short)10,
              (LPSTR)szMessage,
              (short)MessageLength );
     EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
 }
 /*
 */


 APPPAINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\APPPAINT.C

 #include "windows.h"
 #include "APP.h"

 extern char szMessage[];
 extern int MessageLength;

 void APPPaint( HWND, WORD, LONG );


 void APPPaint(  hWnd, wParam, lParam )
 HWND hWnd;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
     TextOut( ps.hdc,
              (short)10,
              (short)10,
              (LPSTR)szMessage,
              (short)MessageLength );
     EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
 }
 /*
 */


 ARCC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\ARCC.C

 /*
  *  Function Name:   Arc
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will draw an arc.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_Arc (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   BOOL      bDrawn;
   int   xScreen, yScreen;

   xScreen = GetSystemMetrics (SM_CXSCREEN);
   yScreen = GetSystemMetrics (SM_CYSCREEN);

   bDrawn = Arc (hDC, xScreen / 3, yScreen / 3, (2 * xScreen) / 3, (2 * yScree
       (2 * xScreen) / 5, (2 * yScreen) / 5, xScreen / 2, yScreen / 2);  /* fu

   if (bDrawn != TRUE)
     MessageBeep (MB_OK);  /*  Couldn't Draw the ARC, so BEEP!!!  */

   return;
   }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit (hInstance)
 HANDLE hInstance;
   {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon (hInstance, NULL);
   wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
   wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"Arc";

   if (!RegisterClass ( (LPWNDCLASS) & wcClass))
     return FALSE;

   return TRUE;
   }


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     if (!WinInit (hInstance))
       return FALSE;

   hWnd = CreateWindow ( (LPSTR)"Arc", (LPSTR)"Arc ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       CALL_Arc (hWnd, ps.hdc);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 ATOM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\ATOM.C

 /*  Atom.c
  *
  * This program is designed to be used in conjunction with atom2. These
  * two programs will demonstrate the use of atoms. Atoms are integers
  * that uniquely identify character strings. Atoms are stored in tables.
  * These two programs will share certain global atom tables.
  *
  */
 #include "windows.h"
 #include "stdio.h"
 #include "process.h"

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
        int     IDForAtom;
      int    IDForAtom2;
      int    ActualAtomSize;
      int    AtomMaxSize = 20;
      int     MB_Return;
        HANDLE  hToAtom;
        BOOL     bTableAdded;
        char    szTempBuff[80];
      char    szMainBuff[80];

    bTableAdded = InitAtomTable(101);
       /* Only neccessary if you want more than 37 entries in your atom
        * table. NOTE: 101 is the number of possible entries and should
        * be PRIME
        */

   /* Deal with local atoms  */
   IDForAtom = AddAtom((LPSTR)"This is an Example String");

   IDForAtom = FindAtom((LPSTR)"This is an Example String");
   ActualAtomSize = GetAtomName(IDForAtom, (LPSTR)szTempBuff, AtomMaxSize);
   hToAtom = GetAtomHandle(IDForAtom);

   IDForAtom = DeleteAtom(IDForAtom);

   /* Deal with global atoms  */
   IDForAtom2 = GlobalAddAtom((LPSTR)"This is another");

   sprintf ( szMainBuff, "%s%s%d%s%d", szTempBuff,"ID is : ",IDForAtom,
     "\nID2 is : ", IDForAtom2);
   MB_Return = MessageBox(NULL, (LPSTR)szMainBuff, (LPSTR)"Atom Example", MB_O
   MB_Return = MessageBox(NULL, (LPSTR)"Continue test by Running Atom2", (LPST
 }


 ATOM2.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\ATOM2.C

 /*  Atom2.c
  *
  * This program is designed to be used in conjunction with atom. These
  * two programs will demonstrate the use of atoms. Atoms are integers
  * that uniquely identify character strings. Atoms are stored in tables.
  * These two programs will share certain global atom tables.
  *
  * NOTE: Run atom first.
  *
  */
 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int    IDForAtom;
   int    ActualAtomSize;
   int    AtomMaxSize = 20;
   int    MB_Return;
   HANDLE  hToAtom;
   BOOL    bTableAdded;
   char    szMainBuff[80];
   char    szbuff[20];

   IDForAtom = GlobalFindAtom((LPSTR)"This is another");
   ActualAtomSize = GlobalGetAtomName(IDForAtom, (LPSTR)szbuff, AtomMaxSize);

   sprintf ( szMainBuff, "%s%s%s%d","string retrieved: ",szbuff," ID is : ",ID
   MB_Return = MessageBox(NULL, (LPSTR)szMainBuff, (LPSTR)"Atom2 Example", MB_
   IDForAtom = GlobalDeleteAtom(IDForAtom);
 }


 ATOMICS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\ATOMICS.C

 /*
  * Function (s) demonstrated in this program: AddAtom ()
  *                                           GlobalAddAtom ()
  *                                           FindAtom ()
  *                                           GlobalFindAtom ()
  *                                           GetAtomName ()
  *                                           GlobalGetAtomName ()
  *                                           GetAtomHandle ()
  *                                           DeleteAtom ()
  *                                           GlobalDeleteAtom ()
  * Compiler version: MSC v5.10
  * Description: This program demonstrates the various atom functions availabl
  *              in the Windows 2.03 Software Development Kit.
  */

 #include <windows.h>
 #include "process.h"
 #include "atomics.h"

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int  nCmdShow;
 {
   static char  szAppName [] = "SampleWindow";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   HMENU hMenu;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;
     if (!RegisterClass (&wndclass))
       return FALSE;
   }

   hMenu = LoadMenu (hInstance, "MainMenu");
   hWnd = CreateWindow (szAppName, "The wonders of atoms", WS_OVERLAPPEDWINDOW
       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
       NULL, hMenu, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
   {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
   }
   return (msg.wParam);
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   int  IDForAtom, IDForAtom2, ActualAtomSize, AtomMaxSize = 20, MB_Return;
   HANDLE   hToAtom;
   BOOL     bTableAdded;
   char  szbuff[20];

   switch (iMessage)
   {
   case WM_COMMAND:
     switch (wParam)
     {
     case IDM_EXECUTE:
       bTableAdded = InitAtomTable (101);
 /* Only neccessary if you want more
                  than 37 entries in your atom table
                  note: 101 is the number of possible
                  entries and should be PRIME */

       IDForAtom = AddAtom ( (LPSTR)"String");
 /* Add the string "String" to the atom table */

       IDForAtom2 = GlobalAddAtom ( (LPSTR)"String2");
 /* Add the string "String2" to the Atom table,
                  making it accessible to other applications. */

       IDForAtom = FindAtom ( (LPSTR)"String");
 /* Search through the atom table and return the atom
                   corresponding to the character string pointed
                   to by (LPSTR)"String". */
       ActualAtomSize = GetAtomName (IDForAtom, (LPSTR)szbuff, AtomMaxSize);
 /* Retrieve a copy of the char string that corresponds to the
                   atom specified by IDForAtom  */
       hToAtom = GetAtomHandle (IDForAtom);
       IDForAtom = DeleteAtom (IDForAtom);
       MB_Return = MessageBox (NULL, (LPSTR)szbuff,
           (LPSTR)"Atom Example", MB_OK);
       IDForAtom = GlobalFindAtom ( (LPSTR)"String2");
       ActualAtomSize = GlobalGetAtomName (IDForAtom, (LPSTR)szbuff,
           AtomMaxSize);
       MB_Return = MessageBox (NULL, (LPSTR)szbuff,
           (LPSTR)"Global Atom Example", MB_OK);
       IDForAtom2 = GlobalDeleteAtom (IDForAtom2);
     }
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, iMessage, wParam, lParam);
   }
   return (0L);
 }




 BGNPAINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\BGNPAINT.C

 /*
  *
  *   bgnpaint.c, jeffst, v1.00, 6-Dec-1987
  *
  *   This program demonstrates the use of the BeginPaint() function.
  *   BeginPaint() prepares the given window for painting and fills the paint
  *   structure with information about the painting. BeginPaint() sets the
  *   clipping region to exclude any area outside the update region. This
  *   is demonstrated in this program by a call to ValidateRect() immediately
  *   before the BeginPaint() call. BeginPaint() is called in response to a
  *   WM_PAINT message in HelloWndProc. This is standard for most window
  *   procedures in Windows applications.
  *
  *   Microsoft Product Support Services
  *   Windows Version 2.0 function demonstration application
  *   Copyright (c) Microsoft 1987
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"BeginPaint";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"BeginPaint",
       (LPSTR)"BeginPaint()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;  /* paint structure filled by BeginPaint() */
     RECT rExcludeRect;  /* area to validate */
     switch (message)
     {
     case WM_SYSCOMMAND:
             return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
   rExcludeRect.top    = 0;
   rExcludeRect.left   = 50;
   rExcludeRect.bottom = 100;
   rExcludeRect.right  = 80;
    /* remove the area described by rExcludeRect from update region */
   ValidateRect(hWnd,(LPRECT)&rExcludeRect);

    /****  prepare window for painting       ****/
   BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
   TextOut(ps.hdc,
     5,
     5,
     (LPSTR)"This line of text messed up by ValidateRect()",
     45);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 BIFF.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFF\BIFF.C

 /*  biff.c
     biff Application
     Windows Toolkit Version 2.10
     Copyright (c) Microsoft 1989 */

 /*  This IS the old HELLO application with
     just one piece of code added to bring
     up a dialog box when a key is pressed.
     See bigg.c for more information.
  */

 #include "windows.h"
 #include "biff.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[20];
 int MessageLength;

 HWND    hWnd;
 HANDLE  hInst;
 FARPROC lpprocAbout;

 extern  void FAR GetBiff(HWND, HANDLE);

 long FAR PASCAL BiffWndProc(HWND, WORD, WORD, LONG);
 BOOL FAR PASCAL BiffDlgProc(HWND, WORD, WORD, LONG);

 BOOL FAR PASCAL About( HWND hDlg, WORD wMessage, WORD wParam, LONG lParam )
 {
     switch (wMessage) {
         case WM_INITDIALOG:
             break;
         case WM_COMMAND:
             EndDialog(hDlg, TRUE);
             break;
         default:
             return FALSE;
             break;
         }
     return(TRUE);
 }


 void BiffPaint( hDC )
 HDC hDC;
 {
     TextOut( hDC, 10, 10,
              (LPSTR)"Press any key to bring up dialog.", 33 );
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL BiffInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pbiffClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pbiffClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pbiffClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pbiffClass->hIcon          = LoadIcon( hInstance, MAKEINTRESOURCE(BIFFICO
     pbiffClass->lpszMenuName   = (LPSTR)NULL;
     pbiffClass->lpszClassName  = (LPSTR)szAppName;
     pbiffClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pbiffClass->hInstance      = hInstance;
     pbiffClass->style          = CS_HREDRAW | CS_VREDRAW;
     pbiffClass->lpfnWndProc    = BiffWndProc;

     if (!RegisterClass( (LPWNDCLASS)pbiffClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pbiffClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HMENU hMenu;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!BiffInit( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szMessage, 15 );
         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL BiffWndProc( HWND hWnd, WORD wMessage, WORD wParam, LONG lPar
 {
     PAINTSTRUCT ps;

     switch (wMessage)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             lpprocAbout = MakeProcInstance( (FARPROC)About, hInst );
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             FreeProcInstance(lpprocAbout);
             break;
         default:
             return DefWindowProc( hWnd, wMessage, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_RBUTTONDOWN:
     case WM_CHAR:

         GetBiff(hWnd, hInst);
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         BiffPaint( ps.hdc );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, wMessage, wParam, lParam );
         break;
     }
     return(0L);
 }


 BIGG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFF\BIGG.C

 /*
    This module was designed to work as a standalone
    program.  What it does is promts you for BIFF
    record information and then builds a biff buffer
    that is copied to the Clipboard and also creates
    a BIFF.XLS file.
 */

 #include "windows.h"
  "winexp.h"  /* needed for file i/o functions */
  "stdlib.h"  /* needed for atof function */
 #include "bigg.h"

 #define BUFLENGTH  100

 extern  HWND  hWnd;

 int     iRow;               /*         INT value from edit control */
 int     iColumn;            /*         INT value from edit control */
 WORD    wInt;               /* BOOL or INT value from edit control */
 int     iTextLength;        /*    length of text from edit control */
 char    szText[40];         /*              text from edit control */
 char    cBuffer[BUFLENGTH];
 int     iLastButton;
 int     iRadioButton;
 int     PlaceBiffOnClipboard( HANDLE );
 int     iLength;
 LPSTR   lpData, lpDataInit;
 FARPROC lpprocBiffDlgProc;

 struct BIFFINTEGER FAR *lpBiffInt;
 struct BIFFNUMBER  FAR *lpBiffNumber;
 struct BIFFSTRING  FAR *lpBiffString;
 struct BIFFFORMULA FAR *lpBiffFormula;

 /* ------ formal declarations -------- */

 BOOL FAR PASCAL BiffDlgProc( HWND, WORD, WORD, LONG );
 HANDLE FillBiffBuffer( void );
 void   CreateBiffBOF(void);
 void   CreateBiffDIM( int, int, int, int );
 void   SaveBiffData(  int, int, int);
 void   CloseBiff(void);
 int    DumpStuff(void);
 void   lstrncpy(LPSTR, LPSTR, int);

 /* -----------------------------------------
      Entry point of this module.
  ------------------------------------------- */
 void FAR GetBiff(HWND hWnd, HANDLE hInst)
 {
    lpprocBiffDlgProc = MakeProcInstance( (FARPROC)BiffDlgProc, hInst );
    DialogBox( hInst, MAKEINTRESOURCE(BIFFDLG), hWnd, lpprocBiffDlgProc );
    FreeProcInstance(lpprocBiffDlgProc);
 }

 /* -----------------------------------------
      Process Biff dialog box.
  ------------------------------------------- */
 BOOL FAR PASCAL BiffDlgProc( HWND hDlg, WORD wMessage, WORD wParam, LONG lPar
 {
    BOOL bResult;  /* Translated flag */

    switch (wMessage) {

    case WM_INITDIALOG:

        SetDlgItemText(hDlg, IDTEXT, (LPSTR)szText);

        CheckRadioButton(hDlg, IDBOOL, IDFORMULA, iLastButton);
            iRadioButton = iLastButton;

        /* formula is not implemented so it is disabled */
        EnableWindow( GetDlgItem(hDlg,IDFORMULA), FALSE );

        break;

    case WM_COMMAND:

        switch (wParam) {

        case IDOK:

            iRow = GetDlgItemInt(hDlg, IDROW , (BOOL FAR *)&bResult, FALSE);
            if (bResult == FALSE) /* display an error. */
                MessageBox( hDlg,
                            (LPSTR)"Non-numeric character or exceeded max!",
                            (LPSTR)"Row Error!", MB_OK );
            if(iRow) iRow--;  // make ZERO based

            iColumn = GetDlgItemInt(hDlg, IDCOLUMN, (BOOL FAR *)&bResult, FALS
            if (bResult == FALSE) /* display an error. */
                MessageBox( hDlg,
                            (LPSTR)"Non-numeric character or exceeded max!",
                            (LPSTR)"Column Error!", MB_OK );

            if(iColumn)  iColumn--; // make ZERO based

            iLastButton = iRadioButton;
            switch (iRadioButton) {
               case IDBOOL:
                    wInt = GetDlgItemInt(hDlg, IDTEXT, (BOOL FAR *)&bResult, F
                    if (bResult == FALSE) /* display an error. */
                        MessageBox( hDlg,
                               (LPSTR)"Something is wrong with BOOL value!",
                               (LPSTR)"BOOL Error!", MB_OK );
                    break;

               case IDINT:
                    wInt = GetDlgItemInt(hDlg, IDTEXT, (BOOL FAR *)&bResult, F
                    if (bResult == FALSE) /* display an error. */
                    MessageBox( hDlg,
                               (LPSTR)"Must be 0 - 65535!",
                               (LPSTR)"Integer Error!", MB_OK );
                    break;

               case IDBLANK:
               case IDLABEL:
               case IDNUMBER:
               case IDFORMULA:

                    break;

               default:
                      MessageBox( hDlg,"Wrong data type", NULL, MB_OK);
            }
            iTextLength = GetDlgItemText(hDlg, IDTEXT, (LPSTR)szText, 40);
            szText[iTextLength+1] = '\0';

            PlaceBiffOnClipboard( FillBiffBuffer() );

            EndDialog(hDlg, TRUE);
            return(TRUE);

        case IDCANCEL:
                EndDialog(hDlg, FALSE);
                return(TRUE);

        case IDBLANK:
        case IDLABEL:
        case IDBOOL:
        case IDINT:
        case IDNUMBER:
        case IDFORMULA:
                CheckRadioButton(hDlg, IDBLANK, IDFORMULA,
                   (iRadioButton = wParam));
                return(TRUE);
                break;
        }
    default:
            return(FALSE);
    }
    return(TRUE);
 }


 /* ----------------------------------------------------------
    Place the biff buffer to the clipboard in BIFF format
  ------------------------------------------------------------ */
 int  PlaceBiffOnClipboard(HANDLE hBiffBuffer)
 {
   WORD     wCBFormat;
   int      iResult;
   unsigned long  ulLength;

   if (hBiffBuffer == 0)
     return FALSE;

   ulLength = (unsigned long)iLength;
   hBiffBuffer = GlobalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, ulLength );
   if (!hBiffBuffer) {
      MessageBox(GetFocus(), "Not enough memory.", NULL, MB_OK);
      return FALSE;
   }
   if ( lpData = GlobalLock(hBiffBuffer) ) {
     lstrncpy( lpData ,lpDataInit, iLength );
   }
   GlobalUnlock(hBiffBuffer);

   if ( OpenClipboard(hWnd) == 0) {
     MessageBox( GetFocus(), (LPSTR)"Opening clipboard", NULL, MB_OK);
     return FALSE;
   }
   EmptyClipboard();
   wCBFormat = RegisterClipboardFormat ( (LPSTR)"Biff" );
   iResult   = SetClipboardData(wCBFormat,hBiffBuffer);
   CloseClipboard();
   return TRUE;

 }

 /* ----------------------
    Fill the Biff buffer
  ------------------------ */
 HANDLE FillBiffBuffer()
 {

   lpDataInit = lpData = cBuffer;  /* set starting address to fill */
   CreateBiffBOF();
   CreateBiffDIM(iRow, iRow, iColumn, iColumn);
   SaveBiffData(iRadioButton, iRow, iColumn);
   CloseBiff();

   DumpStuff();
   return TRUE;

 }


 /* --------------------------------------------------
    Creates a BOF record,
  ---------------------------------------------------- */
 void CreateBiffBOF()
 {

    *lpData++ = 0x9 ; *lpData++ = 0x0 ; // rec type
    *lpData++ = 0x4 ; *lpData++ = 0x0 ; // rec length

    *lpData++ = 0x2 ; *lpData++ = 0x0 ; // version #
    *lpData++ = 0x10; *lpData++ = 0x0 ; // 10 = XLS, 20 = XLC, 40 = XLM

 }

 /* -----------------------------------------------------------
    Creates a Dimension record,
    Currently, this dialog does not:
       1] ask for more than ONE cell.
       2] limits range to two characters.
  ------------------------------------------------------------- */
 void CreateBiffDIM(int iFirstRow, int iLastRow, int iFirstCol, int iLastCol)
 {

    *lpData++ = 0x0;  *lpData++ = 0x0; // rec type
    *lpData++ = 0x8;  *lpData++ = 0x0; // rec length

    *lpData++ = LOBYTE(iFirstRow);  *lpData++ = 0x0; // HIBYTE(iFirstRow);
    *lpData++ = LOBYTE(iLastRow+1); *lpData++ = 0x0; // HIBYTE(iLastRow+1);
    *lpData++ = LOBYTE(iFirstCol);  *lpData++ = 0x0; // HIBYTE(iFirstCol);
    *lpData++ = LOBYTE(iLastCol+1); *lpData++ = 0x0; // HIBYTE(iLastCol+1);

 }

 /* --------------------------------------------------
    Creates a Data record,
  ---------------------------------------------------- */
 void SaveBiffData(int iType, int iRow, int iCol)
 {

   switch (iType) {

    case IDBLANK:   /* make a blank record */

          *lpData++ = 0x1;  *lpData++ = 0x0;// rec type
          *lpData++ = 0x7;  *lpData++ = 0x0;// rec length

          *lpData++ = LOBYTE(iRow); *lpData++ = 0x0; // HIBYTE(iRow); // row
          *lpData++ = LOBYTE(iCol); *lpData++ = 0x0; // HIBYTE(iCol); // col

          *lpData++ = 0x0;  // rec attribute
          *lpData++ = 0x0;
          *lpData++ = 0x0;

          break;


    case IDBOOL:    /* make a boolean record */

          *lpData++ = 0x5;  *lpData++ = 0x0;// rec type
          *lpData++ = 0x9;  *lpData++ = 0x0;// rec length

          *lpData++ = LOBYTE(iRow); *lpData++ = 0x0; // HIBYTE(iRow); // row
          *lpData++ = LOBYTE(iCol); *lpData++ = 0x0; // HIBYTE(iCol); // col

          *lpData++ = 0x0;  // rec attribute
          *lpData++ = 0x0;
          *lpData++ = 0x0;
          *lpData++ = (BYTE)(wInt?0x1:0x0); // data
          *lpData++ = 0x0;

          break;

    case IDINT:     /* make an integer record */
          lpBiffInt = lpData;

          lpBiffInt->wRecType   = 2;
          lpBiffInt->wRecLength = 9;
          lpBiffInt->wRow       = iRow;
          lpBiffInt->wColumn    = iCol;
          lpBiffInt->cAttrib[0] = 0;
          lpBiffInt->cAttrib[1] = 0;
          lpBiffInt->cAttrib[2] = 0;
          lpBiffInt->wInteger   = wInt;

          lpData = lpData + lpBiffInt->wRecLength + 4;

          break;

    case IDNUMBER:  /* make a number record */

          lpBiffNumber = lpData;

          lpBiffNumber->wRecType   =  3;
          lpBiffNumber->wRecLength = 15;
          lpBiffNumber->wRow       = iRow;
          lpBiffNumber->wColumn    = iCol;
          lpBiffNumber->cAttrib[0] = 0;
          lpBiffNumber->cAttrib[1] = 0;
          lpBiffNumber->cAttrib[2] = 0;
          lpBiffNumber->dNumber    = atof((PSTR)szText);

          lpData = lpData + lpBiffNumber->wRecLength + 4;

          break;

    case IDLABEL:   /* make a label (text) record */

          lpBiffString = lpData;

          lpBiffString->wRecType    = 4;
          lpBiffString->wRecLength  = iTextLength+1 + 8;
          lpBiffString->wRow        = iRow;
          lpBiffString->wColumn     = iCol;
          lpBiffString->cAttrib[0]  = 0;
          lpBiffString->cAttrib[1]  = 0;
          lpBiffString->cAttrib[2]  = 0;
          lpBiffString->bTextLength = (BYTE)LOWORD(iTextLength);
          lstrncpy( lpBiffString->cLabel, szText, iTextLength+1 );

          lpData = lpData + lpBiffString->wRecLength + 4 ;

          break;

    case IDFORMULA:  /* make a formula record */ // put here for future use

          lpBiffFormula = lpData;

          lpBiffFormula->wRecType     = 32;
          lpBiffFormula->wRecLength   = iTextLength+1 + 8;
          lpBiffFormula->wRow         = iRow;
          lpBiffFormula->wColumn      = iCol;
          lpBiffFormula->cAttrib[0]   = 0x0;
          lpBiffFormula->cCurValue[0] = 0x0;
          lpBiffFormula->bRecalc      = 0;
          lpBiffFormula->bTextLength  = (BYTE)LOWORD(iTextLength);
          lstrncpy( lpBiffFormula->cLabel, szText, iTextLength+1 );

          lpData = lpData + lpBiffFormula->wRecLength + 4 ;

          break;

    } /* end switch */

 }

 /* ---------------------
    Create an EOF record.
  ----------------------- */
 void CloseBiff()
 {
    *lpData++ = 0xa;  // rec type
    *lpData++ = 0x0;
    *lpData++ = 0x0;
    *lpData++ = 0x0;

 }


 /* --------------------------------------------------
    Dump buffer to a file.
  ---------------------------------------------------- */
 int DumpStuff()
 {
    OFSTRUCT OFFile;
    int      iFile;

    iFile = OpenFile((LPSTR)"dump.xls",
                     (LPOFSTRUCT)&OFFile,OF_CREATE|OF_WRITE);
    if (iFile == -1) {
      MessageBox (GetFocus(),(LPSTR)"OpenFile failed.", NULL, MB_OK);
      return(FALSE);
    }
    iLength = lpData-lpDataInit;
    if (_lwrite(iFile, lpDataInit, iLength) != iLength ) {
      MessageBox (GetFocus(),(LPSTR)"write",(LPSTR)"failed",MB_OK);
    }
    _lclose(iFile);

 }

 /* ---------------------
    Copy number of bytes.
  ----------------------- */

 void lstrncpy(LPSTR lpDest, LPSTR lpSrc, int n)
 {
     while (n--)
       *lpDest++ = *lpSrc++;
 }



 BIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\BIT.C

 /*
  *
  * Functions: hDC CreateDC(lpString, lpString, lpString, lpString)
  *        hDC CreateCompatibleDC(hDC)
  *    HBITMAP LoadBitmap(hInstance, lpString)
  *    hObject SelectObject(hDC, hObject)
  *       BOOL StretchBlt(hDC,X,Y,nWidth,nHeight,hDC,
  *           XSrc,YSrc,XSrcWidth,YSrcHeight,dwROP)
  *       BOOL BitBlt(hDC,X,Y,nWidth,nHeight,hDC,XSrc,YSrc,dwROP)
  *       BOOL DeleteDC(hDC)
  *       BOOL DeleteObject(hObject)
  */
 #include "windows.h"
 #include "stdio.h"

 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   HDC     oneDC, screenDC;
   HBITMAP hWorld;
   int  Index;
   char  LoadBitmapString [40];

   screenDC = CreateDC("DISPLAY", NULL, NULL, NULL);
   oneDC = CreateCompatibleDC(screenDC);
   Index = 1;
   sprintf (LoadBitmapString, "WORLD%i", Index);
   hWorld = LoadBitmap(hInstance, LoadBitmapString);
   SelectObject(oneDC, hWorld);
   StretchBlt(screenDC, 250, 140, 99, 99, oneDC, 0, 0, 99, 99, SRCCOPY);
 /*
     StretchBlt(screenDC, 150, 75, 51, 100, oneDC, 0, 0, 51, 31, SRCCOPY);
     BitBlt(screenDC, 75, 75, 52, 32, oneDC, 0, 0, SRCCOPY);
 */
   DeleteDC(oneDC);
   DeleteDC(screenDC);
   DeleteObject(hWorld);
   return 0;
 }




 BUILDDCB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\BUILDDCB.C

 /*
  *
  * Function(s) demonstrated in this program: BuildCommDCB
  *
  * Windows version:  2.03
  *
  * Windows SDK version:  2.00
  *
  * Compiler version:  C 5.10
  *
  * Description:  This function translates the definition string specified
  *    by the parameter into appropriate device-control block codes and places
  *   these codes in the device control block specified by the other parmeter.
  *
  * Additional Comments:
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "BuildDCB.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];
 char  szMode          [40] = "COM1:9600,N,8,1";


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct {
   char  *szMessage;
 } Messages [] = {
   "About\0",
   "     This is a sample application to demonstrate the\n\
 use of the BuildCommDCB Windows function.",

   "Help Message",
   "     This program uses the BuildCommDCB Windows\n\
 function to build a device control block from the\n\
 given string.  Use the menu to invoke this function.",

 };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
 {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }


 /****************************************************************************

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int  nCmdShow ;
 {
   static char  szAppName [] = "BuildDCB" ;
   HWND        hWnd ;
   WNDCLASS    wndclass ;
   MSG msg;
   short  xScreen, yScreen ;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = szAppName ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
       return FALSE ;
   }

   xScreen = GetSystemMetrics (SM_CXSCREEN) ;
   yScreen = GetSystemMetrics (SM_CYSCREEN) ;

 hWndParent1 = CreateWindow (szAppName,     /* window class name       */
 "BuildCommDCB",             /* window caption          */
 WS_OVERLAPPEDWINDOW,        /* window style            */
 CW_USEDEFAULT,              /* initial x position      */
 0,                          /* initial y position      */
 CW_USEDEFAULT,              /* initial x size          */
 0,                          /* initial y size          */
 NULL,                       /* parent window handle    */
 NULL,                       /* window menu handle      */
 hInstance,                  /* program instance handle */
   NULL) ;                     /* create parameters       */

   ShowWindow (hWndParent1, nCmdShow) ;
   UpdateWindow (hWndParent1) ;

   hInstMain = hInstance;

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 /****************************************************************************

 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   HMENU       hMenu;
   HDC         hDC;
   DCB         CommDCB;
   int  ComVal;
   PAINTSTRUCT ps;

   switch (iMessage)
   {
   case WM_CREATE:
     hMenu = GetSystemMenu (hWnd, FALSE);

     ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
         MF_APPEND | MF_STRING);
     break;

   case WM_SYSCOMMAND:
     switch (wParam)
     {
     case IDM_ABOUT:
       ProcessMessage (hWnd, 0);
       break;
     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
     break;

   case WM_COMMAND:
     switch (wParam)
     {
     case IDM_BUILDDCB:
       sprintf(szOutputBuffer1, "Definition string = COM1:9600,N,8,1");
       MessageBox (hWnd, szOutputBuffer1, "BuildCommDCB", MB_OK);
       ComVal = BuildCommDCB ((LPSTR)szMode, (DCB FAR * ) & CommDCB);
       sprintf (szOutputBuffer2, "%s%s%s%i",
           "     If the return value is 0 then the BuildCommDCB ",
           "function was performed correctly.\n\n",
           "               The return value = ", ComVal);
       MessageBox (hWnd, szOutputBuffer2, "BuildCommDCB", MB_OK);
       break;

     case IDM_HELP:
       ProcessMessage (hWnd, 2);
       break;
     }
     break;

   case WM_PAINT:
     BeginPaint(hWnd, (LPPAINTSTRUCT) & ps);
     EndPaint(hWnd, (LPPAINTSTRUCT) & ps);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
   return (0L);
 }





 BWINTTOP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\BWINTTOP.C

 /*
  *  This program demonstrates the use of the function BringWindowToTop.
  *  It brings a popup style or child style window to the top of a stack
  *  of overlapping windows.
  */

 #include "windows.h"

 /* Registering the parent and child window classes */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
   WNDCLASS   wcParentClass, wcChildClass;

 /* registering the parent window class */
   wcParentClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcParentClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
   wcParentClass.lpszMenuName   = (LPSTR)NULL;
   wcParentClass.lpszClassName  = (LPSTR)"Parent";
   wcParentClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcParentClass.hInstance      = hInstance;
   wcParentClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcParentClass.lpfnWndProc    = DefWindowProc;
   wcParentClass.cbClsExtra     = 0;
   wcParentClass.cbWndExtra     = 0;

   RegisterClass( (LPWNDCLASS) & wcParentClass );

 /* registering the child window class */
   wcChildClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcChildClass.hIcon          = (HICON)NULL;
   wcChildClass.lpszMenuName   = (LPSTR)NULL;
   wcChildClass.lpszClassName  = (LPSTR)"Child";
   wcChildClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcChildClass.hInstance      = hInstance;
   wcChildClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcChildClass.lpfnWndProc    = DefWindowProc;
   wcChildClass.cbClsExtra     = 0;
   wcChildClass.cbWndExtra     = 0;

   RegisterClass( (LPWNDCLASS) & wcChildClass );
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   HWND  hParent, hChild1, hChild2;     /* Handles to the windows */

   WinInit (hInstance);

 /* creating the parent window */
   hParent = CreateWindow((LPSTR)"Parent",
       (LPSTR)"Parent Window",
       WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
     50,                /* x         */
 50,                /* y         */
 600,               /* width     */
 250,               /* height    */
   (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow( hParent, cmdShow );
   UpdateWindow( hParent );

 /* creating the child windows */
   hChild1 = CreateWindow ((LPSTR) "Child",
       (LPSTR) "Child #1",
       WS_CHILD | WS_CLIPSIBLINGS | WS_CAPTION | WS_VISIBLE,
     50,                 /* x         */
 50,                 /* y         */
 100,                /* width     */
 50,                 /* height    */
   (HWND) hParent,     /* parent of this window   */
   (HMENU) 1,          /* child window identifier */
   (HANDLE) hInstance, /* handle to window instance */
   (LPSTR) NULL);      /* no params to pass on    */

   hChild2 = CreateWindow ((LPSTR) "Child",
       (LPSTR) "Child #2",
       WS_CHILD | WS_CLIPSIBLINGS | WS_CAPTION | WS_VISIBLE,
     60,                 /* x          */
 60,                 /* y          */
 100,                /* width      */
 50,                 /* height     */
   (HWND) hParent,     /* parent of this window   */
   (HMENU) 2,          /* child window identifier */
   (HANDLE) hInstance, /* handle to window instance */
   (LPSTR) NULL);      /* no params to pass on    */


 /* Bring the bottom window to the top */
   MessageBox (hParent, (LPSTR)"Before bringing the bottom window up",
       (LPSTR)"Ready ?", MB_OK);

   BringWindowToTop (hChild2);

   MessageBox (hParent, (LPSTR)"Child #2 has been brought up!",
       (LPSTR)"Done", MB_OK);

   return 0;
 }




 CALLMSGF.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\CALLMSGF.C

 /*
  *
  * Function (s) demonstrated in this program: CallMsgFilter, SetWindowsHook,
  *    UnhookWindowsHook
  * Compiler version:  C 5.10
  * Description:  This function calls the Message Filter with the given messag
  *    The message filter is inserted in the Message Filter chain by use of
  *    the SetWindowsHook, and removed using the UnhookWindowsHook.
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "CallMsgF.h"

 extern HWND   hWndMain;

 HWND     hWndMain;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];

 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct   {
   char  *szMessage;
   } Messages [] =   {
 "About",
 "     This is a sample  application to  demonstrate\n\
 the use of the CallMsgFilter, SetWindowsHook, and\n\
 UnhookWindowsHook Windows functions.",

 "Help Message",
 "     This program uses the CallMsgFilter Windows\n\
 function to send a special message to the main\n\
 window.  To test this function use the menu to\n\
 select the option to invoke the function.",

 "CallMsgFilter",
 "     This message was passed to the main window\n\
 by the message filter."

 };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
   {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
   }


 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int  nCmdShow;
   {
   static char  szAppName [] = "CallMsgF";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   short xScreen, yScreen;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

     xScreen = GetSystemMetrics (SM_CXSCREEN);
     yScreen = GetSystemMetrics (SM_CYSCREEN);

     hWndMain = CreateWindow (szAppName,       /* window class name       */
                "CallMsgFilter",               /* window caption          */
                 WS_OVERLAPPEDWINDOW,          /* window style            */
                 CW_USEDEFAULT,                /* initial x position      */
                 0,                            /* initial y position      */
                 CW_USEDEFAULT,                /* initial x size          */
                 0,                            /* initial y size          */
                 NULL,                         /* parent window handle    */
                 NULL,                         /* window menu handle      */
                 hInstance,                    /* program instance handle */
                 NULL);                        /* create parameters       */

     ShowWindow (hWndMain, nCmdShow);
     UpdateWindow (hWndMain);

     hInstMain = hInstance;

     InitHook (hInstMain);

     while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }

     KillHook ();

     return (msg.wParam);
 }


 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU       hMenu;
   MSG         msg;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           ProcessMessage (hWnd, 0);
           break;
         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_CALLMSGFILTER:
           MessageBox (hWnd, "Calling the Message Filter.",
                       "CallMsgFilter", MB_OK);
           msg.hwnd    = hWnd;
           msg.message = WM_COMMAND;
           msg.wParam  = IDM_FILTERMSG;
           msg.lParam  = 0L;

           CallMsgFilter (&msg, HC_ACTION);
           break;

         case IDM_FROMMSGFILTER:
           ProcessMessage (hWnd, 4);
           break;

         case IDM_HELP:
           ProcessMessage (hWnd, 2);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CALLMSGH.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\CALLMSGH.C

 #include <windows.h>
 #include "callmsgh.h"

 HANDLE   hTASK;
 FARPROC  lpfnMessageFilterHook;
 FARPROC  lpfnOldMessageFilterHook;
 HWND     hWnd;

 /****************************************************************************
 void FAR PASCAL InitHook (hTask)
 HANDLE hTask;
   {
   hTASK = hTask;
   lpfnMessageFilterHook = MakeProcInstance ( (FARPROC)CallMsgMessageFilter,
       LIBINST);
   lpfnOldMessageFilterHook = SetWindowsHook (WH_MSGFILTER,
       lpfnMessageFilterHook);
   }


 /****************************************************************************

 BOOL FAR PASCAL KillHook ()
   {
   BOOL  fSuccess;

   fSuccess = UnhookWindowsHook (WH_MSGFILTER, lpfnMessageFilterHook);
   if (fSuccess)
     {
     FreeProcInstance (lpfnMessageFilterHook);
     MessageBox (GetFocus (), "Message filter Unhooked.",
         "Hook", MB_OK);
     }
   return fSuccess;
   }


 /****************************************************************************

 DWORD FAR PASCAL CallMsgMessageFilter (nCode, wParam, lParam)
 int  nCode;
 WORD  wParam;
 LONG  lParam;
   {
   if (nCode == HC_ACTION)
     {
     hWnd = FindWindow (NULL, "CallMsgFilter");
     PostMessage (hWnd, WM_COMMAND, IDM_FROMMSGFILTER, 0L);
     return TRUE;
     }
   else
     return DefHookProc (nCode, wParam, lParam, &lpfnOldMessageFilterHook);
   }


 CATCH.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CATCH.C

 /*
  * Function(s) demonstrated in this program: Catch, Throw
  * Compiler version:  C 5.10
  * Description:  The Catch function catches the current execution environment
  *    and stores it in a buffer.  The Throw function jump to an execution
  *         state described by the parameter.
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "Catch.h"

 HWND     hWndParent1;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];
 CATCHBUF CatchBuf;
 int  CatchVal;

 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct   {
   char  *szMessage;
   } Messages [] =   {
   "About",
   "     This is a sample application to demonstrate the\n\
 use of the Catch and Throw Windows functions.",

   "Help Message",
   "     This program uses the Catch Windows function\n\
 to copy the current state of the execution environment.\n\
 Then the Throw Windows function is used to return to\n\
 the original execution environment.  Use the menu to\n\
 invoke this function.",

   };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND    hWnd;
 int  MessageNumber;
   {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
   }


 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int  nCmdShow;
   {
   static char  szAppName [] = "Catch";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   short xScreen, yScreen;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   xScreen = GetSystemMetrics (SM_CXSCREEN);
   yScreen = GetSystemMetrics (SM_CYSCREEN);

 hWndParent1 = CreateWindow (szAppName,         /* window class name       */
                            "Catch N Throw",    /* window caption          */
                            WS_OVERLAPPEDWINDOW,/* window style            */
                            CW_USEDEFAULT,      /* initial x position      */
                            0,                  /* initial y position      */
                            CW_USEDEFAULT,      /* initial x size          */
                            0,                  /* initial y size          */
                            NULL,               /* parent window handle    */
                            NULL,               /* window menu handle      */
                            hInstance,          /* program instance handle */
                            NULL);              /* create parameters       */

   ShowWindow (hWndParent1, nCmdShow);
   UpdateWindow (hWndParent1);

   hInstMain = hInstance;

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return (msg.wParam);
   }


 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU       hMenu;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);

       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                   MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           ProcessMessage (hWnd, 0);
           break;
         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_CATCH:
           if (CatchVal = Catch((LPCATCHBUF)CatchBuf))
             {
             switch (CatchVal)
               {
               case ID_ERROR:
                 MessageBox(hWnd,
                            "This message made possible by the Throw function"
                            "Catch N Throw",
                            MB_OK | MB_ICONHAND | MB_SYSTEMMODAL);
                 break;
               }
             return 0L;
             }
           MessageBox (hWnd, "    About to use Throw to make a jump",
                       "Catch N Throw", MB_OK);
           Throw((LPCATCHBUF)CatchBuf, ID_ERROR);
           break;

         case IDM_HELP:
           ProcessMessage (hWnd, 2);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

       default:
         return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CHECKDLG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\CHECKDLG.C

 /*
  *
  *   checkdlg.c
  *
  *   This program demonstrates the use of the CheckDlgButton() function.
  *   CheckDlgButton() checks, unchecks, or disables dlg controls (where
  *   applicable). CheckDlgButton() is called from DialogBoxProc() in
  *   this sample application.
  *
  */

 #include "windows.h"
 #include "checkdlg.h"

 HANDLE hInst;

 FARPROC lpprocDialog;
 long    FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND      hDlg;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_INITDIALOG:
       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case ID_BUTTON1:
           break;

         case ID_BUTTON2:
           /* gray button with ID_BUTTON2 id */
           CheckDlgButton(hDlg, ID_BUTTON1, 2);
           break;

         case ID_BUTTON3:
           /* uncheck button with ID_BUTTON2 id */
           CheckDlgButton(hDlg, ID_BUTTON1, 0);
           break;

         case ID_BUTTON4:
           /* check button with ID_BUTTON2 id */
           CheckDlgButton(hDlg, ID_BUTTON1, 1);
           break;

         case ID_OK:
           EndDialog(hDlg, TRUE);
           break;
         }
       break;

     default:
       return FALSE;
     }
   }

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit(hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pHelloClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon(hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)"min";
   pHelloClass->lpszClassName  = (LPSTR)"CheckDlgButton";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass((LPWNDCLASS)pHelloClass))
     return FALSE;     /* Initialization failed */

   LocalFree((HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit(hInstance);
   hWnd = CreateWindow((LPSTR)"CheckDlgButton",
                       (LPSTR)"CheckDlgButton()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */
   hInst = hInstance;

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
       DialogBox(hInst, MAKEINTRESOURCE(2), hWnd, lpprocDialog);
       FreeProcInstance((FARPROC)lpprocDialog);
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
   }


 CHILDFP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\CHILDFP.C

 /*
  * Function(s) demonstrated in this program: ChildWindowFromPoint
  * Compiler version:  C 5.10
  * Description:  This function determines which, if any, of the child windows
  *               belonging to the given parent window contains the specified
  *               point.
  * Additional Comments:  This program also illustrates the subclassing of
  *                       windows.
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "childfp.h"

 char  szMessageBuffer [150] = "    Demo Program (ChildWindowFromPoint).";

 char    szHelpBuffer [200] = "     Choose to enter point coordinates, or\n\
 let the computer choose random coordinates.\n\
 The program will use the ChildWindowFromPoint\n\
 function to compute which window the point\n\
 resides in.";

 HWND     hWndMain, hWndChild1, hWndChild2, hX, hY, hOK2;
 HANDLE   hInstMain;
 FARPROC  lpProcEnterPoint;
 FARPROC  lpProcNewEnterPoint;
 FARPROC  lpProcOldX;
 FARPROC  lpProcOldY;

 char  szXValue [40];
 char  szYValue [40];

 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int     nCmdShow;
   {
   static char   szAppName [] = "ChildFp";
   static char   szChildClass [] = "ChildFpChild";

   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   short xScreen, yScreen;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;

     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = ChildWndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = NULL;
     wndclass.hCursor       = LoadCursor (NULL, IDC_CROSS);
     wndclass.hbrBackground = GetStockObject (LTGRAY_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szChildClass;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   xScreen = GetSystemMetrics (SM_CXSCREEN);
   yScreen = GetSystemMetrics (SM_CYSCREEN);

   hWnd = CreateWindow (szAppName,                /* window class name       *
                       "Child Window From Point", /* window caption          *
                       WS_OVERLAPPEDWINDOW,       /* window style            *
                       CW_USEDEFAULT,             /* initial x position      *
                       0,                         /* initial y position      *
                       CW_USEDEFAULT,             /* initial x size          *
                       0,                         /* initial y size          *
                       NULL,                      /* parent window handle    *
                       NULL,                      /* window menu handle      *
                       hInstance,                 /* program instance handle *
                       NULL);                     /* create parameters       *

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

   hWndMain  = hWnd;
   hInstMain = hInstance;

   hWndChild1 = CreateWindow (szChildClass, "Child 1", WS_CHILD |
                              WS_CAPTION | WS_SYSMENU |
                              WS_THICKFRAME | WS_MAXIMIZEBOX |
                              WS_CLIPSIBLINGS,
                              xScreen / 9, yScreen / 8,
                              xScreen / 3, yScreen / 2,
                              hWndMain, 1, hInstance, NULL);

   ShowWindow (hWndChild1, SW_SHOWNORMAL);
   UpdateWindow (hWndChild1);

   hWndChild2 = CreateWindow (szChildClass, "Child 2", WS_CHILD |
                              WS_CAPTION | WS_SYSMENU |
                              WS_THICKFRAME | WS_MAXIMIZEBOX |
                              WS_CLIPSIBLINGS,
                              5 * xScreen / 9, yScreen / 8,
                              xScreen / 3, yScreen / 2,
                              hWndMain, 1, hInstance, NULL);

   ShowWindow (hWndChild2, SW_SHOWNORMAL);
   UpdateWindow (hWndChild2);

   lpProcEnterPoint    = MakeProcInstance (EnterPointDlgProc, hInstance);
   lpProcNewEnterPoint = MakeProcInstance (NewEnterPointDlgProc, hInstance);

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return (msg.wParam);
   }

 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU         hMenu;
   POINT         pt;
   static int    xClient, yClient;
   char          szOutputBuffer [40];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SIZE:
       xClient = LOWORD (lParam);
       yClient = HIWORD (lParam);
       sprintf (szOutputBuffer, "Width = %i, Height = %i", xClient, yClient);
       MessageBox (hWnd, szOutputBuffer, "Client Window Dimensions", MB_OK);
       break;

     case WM_LBUTTONDBLCLK:
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           MessageBox (hWnd, szMessageBuffer, (LPSTR)"About", MB_OK);
           break;
         default:
         return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_CHOOSERANDOM:
           pt.x = pt.y = -1;
           while (((pt.x < 0) || (pt.x > xClient)) || ((pt.y < 0) ||
                  (pt.y > yClient)))
             {
             pt.x = (rand () / 47);
             pt.y = (rand () / 102);
             }
           hWnd = ChildWindowFromPoint (hWnd, pt);
           sprintf (szOutputBuffer, "The Point [%i, %i]", pt.x, pt.y);
           if (hWnd == hWndChild1)
             MessageBox (hWnd, "is in Child Window 1", szOutputBuffer,
                         MB_OK);
           else
             if (hWnd == hWndChild2)
               MessageBox (hWnd, "is in Child Window 2", szOutputBuffer,
                           MB_OK);
             else
               MessageBox (hWnd, "is not in a Child Window",
                           szOutputBuffer, MB_OK);
           break;

         case IDM_CHOOSE:
           pt.x = pt.y = -1;
           while (((pt.x < 0) || (pt.x > xClient)) || ((pt.y < 0) ||
                  (pt.y > yClient)))
             {
             DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                        lpProcEnterPoint);
             pt.x = atoi (szXValue);
             pt.y = atoi (szYValue);
             }
           hWnd = ChildWindowFromPoint (hWnd, pt);
           sprintf (szOutputBuffer, "The Point [%i, %i]", pt.x, pt.y);
           if (hWnd == hWndChild1)
             MessageBox (hWnd, "is in Child Window 1", szOutputBuffer,
                         MB_OK);
           else
             if (hWnd == hWndChild2)
               MessageBox (hWnd, "is in Child Window 2", szOutputBuffer,
                           MB_OK);
           else
             MessageBox (hWnd, "is not in a Child Window",
                         szOutputBuffer, MB_OK);
           break;

         case IDM_HELP:
           MessageBox (hWnd, szHelpBuffer, "Help Message", MB_OK);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }

 /****************************************************************************

 long    FAR PASCAL ChildWndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   return DefWindowProc (hWnd, iMessage, wParam, lParam);
   }


 /****************************************************************************

 BOOL FAR PASCAL EnterPointDlgProc (hDlg, iMessage, wParam, lParam)
 HWND     hDlg;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   switch (iMessage)
     {
     case WM_INITDIALOG:
       SendDlgItemMessage (hDlg, IDD_X, EM_LIMITTEXT, (WORD)40, 0L);
       SendDlgItemMessage (hDlg, IDD_Y, EM_LIMITTEXT, (WORD)40, 0L);

       hX = GetDlgItem (hDlg, IDD_X);
       lpProcOldX = (FARPROC) GetWindowLong (hX, GWL_WNDPROC);
       SetWindowLong (hX, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
       SendMessage (hX, EM_SETSEL, 0, MAKELONG (0, 32767));
       hY = GetDlgItem (hDlg, IDD_Y);
       lpProcOldY = (FARPROC) GetWindowLong (hY, GWL_WNDPROC);
       SetWindowLong (hY, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
       SendMessage (hY, EM_SETSEL, 0, MAKELONG (0, 32767));
       hOK2 = GetDlgItem (hDlg, IDOK);

       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDD_X:
           break;

         case IDD_Y:
           break;

         case IDOK:
           GetDlgItemText (hDlg, IDD_X, szXValue, 10);
           GetDlgItemText (hDlg, IDD_Y, szYValue, 10);
           EndDialog (hDlg, TRUE);
           break;

         default:
           return FALSE;
         }
     default:
       return FALSE;
     }
   return TRUE;
   }


 /****************************************************************************

 BOOL FAR PASCAL NewEnterPointDlgProc  (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   switch (iMessage)
     {
     case WM_GETDLGCODE:
       return (DLGC_WANTALLKEYS);

     case WM_CHAR:
       if ((wParam == VK_TAB) || (wParam == VK_RETURN))
         {
         SendMessage (hWndMain, WM_USER, 0, 0L);
         SetFocus (FindNextWindow (hWnd));
         return TRUE;
         }
       else
         {
         if (hWnd == hX)
           return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                   iMessage, wParam, lParam));
         if (hWnd == hY)
           return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                   iMessage, wParam, lParam));
         }
       break;

     default:
       if (hWnd == hX)
         return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                 iMessage, wParam, lParam));
       if (hWnd == hY)
         return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                 iMessage, wParam, lParam));
     }
   }


 /****************************************************************************

 HWND FindNextWindow (hWnd)
 HWND   hWnd;
   {
   if (hWnd == hX)
     return hY;
   if (hWnd == hY)
     return hOK2;
   return NULL;
   }


 CHMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\CHMENU.C

 /*
  *  Function Name:   ChangeMenu
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will add new items to a menu.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_ChangeMenu(hWnd)
 HWND hWnd;
   {
   HMENU     hSubItem;
   HMENU     hCurrentWindowMenu;
   unsigned  wIDNewItem1, wIDNewItem2;    /* assign items numbers for ID */
   BOOL      bChanged1;

   hCurrentWindowMenu = CreateMenu();
   hSubItem           = CreateMenu();
     /* menu heading created. */
   bChanged1 = ChangeMenu (hCurrentWindowMenu, NULL, (LPSTR) "Heading",
       hSubItem, MF_APPEND | MF_BYPOSITION | MF_POPUP);

   if (bChanged1 == FALSE)
     MessageBox(hWnd, (LPSTR)"ChangeMenu failed", (LPSTR)"ERROR", MB_ICONHAND)

    /* 2 items added under Heading */
   ChangeMenu (hSubItem, NULL, (LPSTR) "Item1", wIDNewItem1,
               MF_APPEND | MF_BYCOMMAND | MF_STRING);
   ChangeMenu (hSubItem, NULL, (LPSTR) "Item2", wIDNewItem2,
               MF_APPEND | MF_BYCOMMAND | MF_STRING);
   SetMenu(hWnd, hCurrentWindowMenu);

   return;
   }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit(hInstance)
 HANDLE hInstance;
   {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon(hInstance, NULL);
   wcClass.hCursor        = LoadCursor(NULL, IDC_ARROW);
   wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"ChangeMenu";

   if (!RegisterClass((LPWNDCLASS) & wcClass))
     return FALSE;

   return TRUE;
   }

 int     PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     if (!WinInit(hInstance))
       return FALSE;
     }

   hWnd = CreateWindow((LPSTR)"ChangeMenu",
                      (LPSTR)"ChangeMenu()",
                      WS_OVERLAPPEDWINDOW,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      (HWND)NULL,        /* no parent */
                      (HMENU)NULL,       /* use class menu */
                      (HANDLE)hInstance, /* handle to window instance */
                      (LPSTR)NULL );     /* no params to pass on */

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

         /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_CREATE:
       CALL_ChangeMenu (hWnd); /* Change the menu when the window is created *
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
   }


 CHORD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CHORD.C

 /*
  *   This program demonstrates the use of the Chord() function.
  *   Chord() draws a chord. Chord() is called in response to a WM_PAINT
  *   message in HelloWndProc();
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit(hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pHelloClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon(hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName   = (LPSTR)"Chord";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass((LPWNDCLASS)pHelloClass))
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   LocalFree((HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit(hInstance);
   hWnd = CreateWindow((LPSTR)"Chord",
                       (LPSTR)"Chord()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL );     /* no params to pass on */

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
     }

   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc(hWnd, message, wParam, lParam)
 HWND       hWnd;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
   {
   PAINTSTRUCT ps;
   BOOL bDrawn;       /* was the chord drawn? */

   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     case WM_PAINT:
       BeginPaint(hWnd, (LPPAINTSTRUCT) & ps);
       bDrawn = Chord(ps.hdc, 5, 5, 100, 100, 0, 22, 150, 22);
                   /***** draw the chord *****/
       if (!bDrawn)
         MessageBox(NULL,
                    (LPSTR)"Chord failed!",
                    (LPSTR)"Chord info:",
                    MB_OK);          /* Tell User it didn't work */
       EndPaint(hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
   }


 CKMNUITM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\CKMNUITM.C

 /*
  *   This program demonstrates the use of the CheckMenuItem() function.
  *   CheckMenuItem() checks or unchecks the given menu item. CheckMenuItem()
  *   is called in response to a WM_COMMAND message in HelloWndProc() in
  *   this sample application.
  */

 #include "windows.h"
 #include "ckmnuitm.h"

 WORD   mOldChoice = NULL;   /* the last chosen menu item */
 HMENU  hMenu;        /* handle to menu of window  */

 long    FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit(hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pHelloClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon(hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)"menucnt";
   pHelloClass->lpszClassName  = (LPSTR)"CheckMenuItem";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass((LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree((HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit(hInstance);
   hWnd = CreateWindow((LPSTR)"CheckMenuItem",
                       (LPSTR)"CheckMenuItem()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL );     /* no params to pass on */

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   hMenu = GetMenu(hWnd);     /* get the handle to the menu */

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_COMMAND:
       switch( wParam )
         {
         case IDM_CHOICE1:
         case IDM_CHOICE2:
         case IDM_CHOICE3:
           if (mOldChoice)  /* if another menu item previously chosen */
             CheckMenuItem(hMenu, mOldChoice, MF_UNCHECKED);   /* uncheck it *
           mOldChoice = wParam;  /* keep track of this choice for later */
           CheckMenuItem(hMenu, mOldChoice, MF_CHECKED);   /* check the new ch
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
   }


 CKRADBTN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\CKRADBTN.C

 /*
  *   This program demonstrates the use of the CheckRadioButton() function.
  *   CheckRadioButton() checks one radio button and unchecks all other radio
  *   buttons with identifiers in the range specified by the 2nd and 3rd
  *   parameters. CheckRadioButton() is called from DialogBoxProc() in this
  *   sample application.
  */

 #include "windows.h"
 #include "ckradbtn.h"

 HANDLE hInst;

 FARPROC lpprocDialog;
 long    FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL DialogBoxProc(HWND, unsigned, WORD, LONG);

 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND      hDlg;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_INITDIALOG:
       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case ID_RADIO1:
         case ID_RADIO2:
         case ID_RADIO3:
         case ID_RADIO4:
           CheckRadioButton(hDlg, ID_RADIO1, ID_RADIO4, wParam);
               /* check the chosen radio button, uncheck the rest */
           break;

         case ID_OK:
           EndDialog(hDlg, TRUE);
           break;
         }
       break;

     default:
       return FALSE;
       break;
     }
   }


 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit(hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pHelloClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon(hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)"min";
   pHelloClass->lpszClassName   = (LPSTR)"CheckRadioButton";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass((LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree((HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit(hInstance);
   hWnd = CreateWindow((LPSTR)"CheckRadioButton",
                       (LPSTR)"CheckRadioButton()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL );     /* no params to pass on */
   hInst = hInstance;

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
     }

   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   HMENU  hMenu;

   switch (message)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();  /*  Create a Menu  */
       ChangeMenu (hMenu, NULL, "Dialog", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
         DialogBox(hInst, MAKEINTRESOURCE(2), hWnd, lpprocDialog);
         FreeProcInstance((FARPROC)lpprocDialog);
         break;
         }
       else
         return DefWindowProc(hWnd, message, wParam, lParam);
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
   }


 CLEARCOM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\CLEARCOM.C

 /*
  *
  * Function (s) demonstrated in this program: ClearCommBreak, CloseComm,
  *    OpenComm, SetCommBreak
  *
  * Compiler version:  C 5.10
  *
  * Description:  This function restores character transmission and places the
  *    transmission line in a nonbreak state.
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "ClearCom.h"

 HWND     hWndParent1;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct   {
   char  *szMessage;
   } Messages [] =   {
   "About\0",
   "     This is a sample application to demonstrate the\n\
 use of the ClearCommBreak, CloseComm, OpenComm, and\n\
 SetCommBreak Windows functions.",

       "Help Message",
   "     This program uses the ClearCommBreak Windows\n\
 function to restore character transmission to the\n\
 comm port and places the transmission line in a\n\
 nonbreak state.  nResult should be 0 if the function\n\
 was successful.  Use the menu to invoke this\n\
 function.",

   };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
   {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
   }

 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
   {
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = "ClearCom";
     wndclass.lpszClassName = "ClearCom";

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWndParent1 = CreateWindow (szAppName,          /* window class name
                              "ClearCommBreak",    /* window caption
                              WS_OVERLAPPEDWINDOW, /* window style
                              CW_USEDEFAULT,       /* initial x position
                              0,                   /* initial y position
                              CW_USEDEFAULT,       /* initial x size
                              0,                   /* initial y size
                              NULL,                /* parent window handle
                              NULL,                /* window menu handle
                              hInstance,           /* program instance handle
                              NULL);               /* create parameters

   ShowWindow (hWndParent1, nCmdShow);
   UpdateWindow (hWndParent1);

   hInstMain = hInstance;

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   int    nCid;
   int    nResult;
   HMENU  hMenu;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           ProcessMessage (hWnd, 0);
           break;
         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_CLEARCOM:
           nCid = OpenComm ( (LPSTR)"LPT1", 255, 256);
           sprintf (szOutputBuffer1, "nCid = %i", nCid);
           MessageBox (hWnd, szOutputBuffer1, "OpenComm", MB_OK);

           nResult = SetCommBreak (nCid);
           sprintf (szOutputBuffer1, "nResult = %i", nResult);
           MessageBox (hWnd, szOutputBuffer1, "SetCommBreak", MB_OK);

           nResult = ClearCommBreak (nCid);
           sprintf (szOutputBuffer1, "nResult = %i", nResult);
           MessageBox (hWnd, szOutputBuffer1, "ClearCommBreak", MB_OK);

           nResult = CloseComm (nCid);
           sprintf (szOutputBuffer1, "nResult = %i", nResult);
           MessageBox (hWnd, szOutputBuffer1, "CloseComm", MB_OK);
           break;

         case IDM_HELP:
           ProcessMessage (hWnd, 2);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CLIENTSC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\CLIENTSC.C

 /*
  *   This program demonstrates the use of the ClientToScreen () function.
  *   ClientToScreen () converts client area coordinates to screen coordinates
  *   (upper left of the screen being the origin). ClientToScreen () is called
  *   from ParentWndProc () in response to a WM_SIZE or WM_MOVE message.
  *
  */

 #include <windows.h>

 int     PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
 long    FAR PASCAL ParentWndProc (HWND, unsigned, WORD, LONG);
 long    FAR PASCAL PopupWndProc (HWND, unsigned, WORD, LONG);
 int     sprintf (char *, const char *, ...);

 HWND    hChild;
 char    szBuff[80] = " ";   /*          used for output           */
 short   nTextLength = 0;    /*   length of string for TextOut ()  */


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG      msg;
   HWND     hParent;
   WNDCLASS wndClass;

   if (!hPrevInstance)
     {
     wndClass.style          = CS_HREDRAW | CS_VREDRAW;
     wndClass.lpfnWndProc    = ParentWndProc;
     wndClass.cbClsExtra     = 0;
     wndClass.cbWndExtra     = 0;
     wndClass.hInstance      = hInstance;
     wndClass.hIcon          = LoadIcon (NULL, NULL);
     wndClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wndClass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     wndClass.lpszMenuName   = NULL;
     wndClass.lpszClassName  = "ClientToScreenParent";

     if (!RegisterClass (&wndClass))
       return FALSE;

     wndClass.style          = CS_HREDRAW | CS_VREDRAW;
     wndClass.lpfnWndProc    = PopupWndProc;
     wndClass.cbClsExtra     = 0;
     wndClass.cbWndExtra     = 0;
     wndClass.hInstance      = hInstance;
     wndClass.hIcon          = NULL;
     wndClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wndClass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     wndClass.lpszMenuName   = NULL;
     wndClass.lpszClassName  = "ClientToScreenPopup";

     if (!RegisterClass (&wndClass))
       return FALSE;
     }

   hParent = CreateWindow ( (LPSTR)"ClientToScreenParent",
                          (LPSTR)"Parent Window for ClientToScreen () Demo",
                          WS_OVERLAPPEDWINDOW,
                          32,
                          200,
                          500,
                          48,
                          NULL,      /* no parent */
                          NULL,      /* use class menu */
                          hInstance, /* handle to window instance */
                          NULL);     /* no params to pass on */

   ShowWindow (hParent, cmdShow);
   UpdateWindow (hParent);

   hChild = CreateWindow ( (LPSTR)"ClientToScreenPopup",
                         (LPSTR)"Popup Window for ClientToScreen () Demo",
                         WS_POPUP | WS_CAPTION | WS_VISIBLE,
                         32,
                         256,
                         500,
                         48,
                         hParent,
                         NULL,      /* use class menu */
                         hInstance, /* handle to window instance */
                         NULL);     /* no params to pass on */

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }

   return (int)msg.wParam;
   }

 long    FAR PASCAL ParentWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   POINT myPoint;       /* point structure used in calls to ClientToScreen ()

   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_MOVE:
     case WM_SIZE:
       DefWindowProc (hWnd, message, wParam, lParam);
       myPoint.x = 0;
       myPoint.y = 0;
       ClientToScreen (hWnd, (LPPOINT) & myPoint);
       nTextLength = sprintf (szBuff,
           "Screen Coordinates of Upper Left-hand Corner: (%d, %d)",
           myPoint.x,
           myPoint.y);
       InvalidateRect (hChild, NULL, TRUE);
       UpdateWindow (hChild);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     break;
     }
   return (0L);
   }

 long    FAR PASCAL PopupWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, &ps);
       TextOut (ps.hdc, 5, 5, szBuff, nTextLength);
       EndPaint (hWnd, &ps);
       break;
     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CLIPBOX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CLIPBOX.C

 /*
  *  Function (s) demonstrated in this program: GetClipbox
  *  Description: This function retrieves the dimensions of the tightest
  *               bounding rectangle around the current clipping boundary.
  *               The dimensions are copied to the buffer pointed to by the
  *               last parameter.
  */

 #include <windows.h>
 #include <stdio.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 HDC hDC;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  rClass;
   MSG       msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "CLIPBOX";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow ("CLIPBOX",
       "GetClipBox",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       0,
       CW_USEDEFAULT,
       0,
       NULL,
       NULL,
       hInstance,
       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   hDC = GetDC (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU  hMenu;
   HRGN   hRgnBox;
   HRGN   hRgnCircle;
   HRGN   hRgnBoth;
   RECT   lpRect;
   short  nRgnType;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"CheckType", 100, MF_APPEND);
       ChangeMenu (hMenu, NULL, (LPSTR)"Set Complex", 200, MF_APPEND);
       ChangeMenu (hMenu, NULL, (LPSTR)"Set Simple", 300, MF_APPEND);
       ChangeMenu (hMenu, NULL, (LPSTR)"Set Null", 400, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

   case WM_COMMAND:
     switch (wParam)
       {
       case 100:
         nRgnType = GetClipBox (hDC, (LPRECT) & lpRect);
         switch (nRgnType)
           {
           case ERROR:
             MessageBox (hWnd, (LPSTR)"Device context is not valid",
                 (LPSTR)"GetClipBox", MB_OK | MB_ICONEXCLAMATION);
             break;
           case NULLREGION:
             MessageBox (hWnd, (LPSTR)"Clipping region is empty",
                 (LPSTR)"GetClipBox", MB_OK);
             break;
           case SIMPLEREGION:
             MessageBox (hWnd, (LPSTR)"Clipping region is simple",
                 (LPSTR)"GetClipBox", MB_OK);
             break;
           case COMPLEXREGION:
             MessageBox (hWnd, (LPSTR)"Clipping region is complexed",
                 (LPSTR)"GetClipBox", MB_OK);
             break;
           }
         InvalidateRect (hWnd, (LPRECT)NULL, TRUE);
         break;

       case 200:
         hRgnBox = CreateRectRgn (50, 75, 125, 150);
         hRgnCircle = CreateEllipticRgn (50, 25, 150, 125);
         hRgnBoth = CreateRectRgn (0, 0, 0, 0);
         CombineRgn (hRgnBoth, hRgnBox, hRgnCircle, RGN_XOR);
         SelectClipRgn (hDC, hRgnBoth);
         break;

       case 300:
         hRgnBox = CreateRectRgn (200, 225, 225, 250);
         SelectClipRgn (hDC, hRgnBox);
         break;

       case 400:
         hRgnBox = CreateRectRgn (0, 0, 0, 0);
         SelectClipRgn (hDC, hRgnBox);
         break;
       }
     break;

     case WM_DESTROY:
       ReleaseDC (hWnd, hDC);
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CLIPCHAN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPCHAN.C

 /*
  *  This program demonstrates the use of ChangeClipboardChain function.
  *  This funtion removes the window specified by a handle from the chain
  *  of clipboard viewers and makes the window next in the viewer chain the
  *  descendent of the removing window's ancestor.
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 static char  szAppName[] = "clipchan";
 static char  szFuncName[] = "ChangeClipboardChain";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   WNDCLASS rClass;
   HWND     hWnd;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Clipboard Chain", 100, MF_APPEND);

   hWnd = CreateWindow (szAppName,            /* window class name       */
                       szFuncName,                 /* window caption
                       WS_OVERLAPPEDWINDOW,        /* window style
                       CW_USEDEFAULT,              /* initial x position
                       0,                          /* initial y position
                       CW_USEDEFAULT,              /* initial x size
                       0,                          /* initial y size
                       NULL,                       /* parent window handle
                       hMenu,                      /* window menu handle
                       hInstance,                  /* program instance handle
                       NULL);                     /* create parameters       *

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND        hWnd;
 unsigned    iMessage;
 WORD        wParam;
 LONG        lParam;
   {
   HMENU  hMenu;
   HWND   hWndStatic;
   BOOL   bRemoved;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         hWndStatic = SetClipboardViewer (hWnd);
         MessageBox (NULL,
             (LPSTR)"Removing current window from the viewer chain",
             (LPSTR)szFuncName, MB_OK);
         bRemoved = ChangeClipboardChain (hWnd, hWndStatic);
         if (bRemoved != 0)
           MessageBox (NULL,
               (LPSTR)"Current window removed from the viewer chain",
               (LPSTR)szFuncName, MB_OK);
         else
           MessageBox (NULL,
               (LPSTR)"Current window not removed from viewer chain",
               (LPSTR)szFuncName, MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPCLOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPCLOS.C

 /*
  *  This program demonstrates the use of CloseClipboard function.
  *  This function close the clipboard. ClipClipboard should be called when
  *  a window has finished examining or changing the clipboard. It lets
  *  other application access the clipboard.
  */

 #include <windows.h>

 static char  szAppName[] = "clipclos";
 static char  szFuncName[] = "CloseClipboard";

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  rClass;
   MSG       msg;
   HMENU     hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();  /*  Add a Menu Item  */
   ChangeMenu (hMenu, NULL, (LPSTR)"Close Clipboard", 100, MF_APPEND);

   hWnd = CreateWindow (szAppName,          /* window class name       */
                       szFuncName,          /* window caption          */
                       WS_OVERLAPPEDWINDOW, /* window style            */
                       CW_USEDEFAULT,       /* initial x position      */
                       0,                   /* initial y position      */
                       CW_USEDEFAULT,       /* initial x size          */
                       0,                   /* initial y size          */
                       NULL,                /* parent window handle    */
                       hMenu,               /* window menu handle      */
                       hInstance,           /* program instance handle */
                       NULL);               /* create parameters       */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned  iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   HMENU  hMenu;
   BOOL   bClosed;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         OpenClipboard (hWnd);
         MessageBox (NULL, (LPSTR)"Closing clipboard", (LPSTR)szFuncName,
             MB_OK);
         bClosed = CloseClipboard ();
         if (bClosed != 0)
           MessageBox (NULL, (LPSTR)"Clipboard closed", (LPSTR)szFuncName,
                MB_OK);
         else
           MessageBox (NULL, (LPSTR)"Clipboard not closed", (LPSTR)szFuncName,
               MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPCOUN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPCOUN.C

 /*
  *  This program demonstrates the use of CountClipboardFormats function.
  *  This function retieves a count of the number of formats that the clip-
  *  board can render.
  */

 #include <windows.h>
 #include <stdio.h>

 static char  szAppName[] = "clipcoun";
 static char  szFuncName[] = "CountClipboardFormats";

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName,
                       szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND        hWnd;
 unsigned    iMessage;
 WORD        wParam;
 LONG        lParam;
   {
   HMENU  hMenu;
   int  nCount;
   char  szBuff[80];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Clipboard Formats", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         MessageBox (NULL, (LPSTR)"Counting clipboard formats",
                    (LPSTR)szFuncName, MB_OK);
         nCount = CountClipboardFormats ();
         sprintf (szBuff, "There is %d clipboard formats right now.", nCount);
         MessageBox (NULL, (LPSTR)szBuff, (LPSTR)szFuncName, MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;
     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPCURS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\CLIPCURS.C

 /*
  *   This program demonstrates use of the ClipCursor () function.
  *   ClipCursor () confines movement of the cursor to the rectangle specified
  *   by the "lpRect" parameter . In WinMain (), GetClientRect () is
  *   called, then ClientToScreen () is called to convert the client area
  *   coordinates to screen coordinates (because ClipCursor () is a screen-
  *   coordinate relative function).  ClipCursor () is then called to confine
  *   the cursor to the left half of the client area.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"ClipCursor";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   RECT  rClientRect;
   POINT UpperLeft;
   POINT LowerRight;

   HelloInit (hInstance);
   hWnd = CreateWindow ( (LPSTR)"ClipCursor",
                       (LPSTR)"ClipCursor ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   GetClientRect (hWnd, (LPRECT) & rClientRect);
   UpperLeft.x  = rClientRect.left;
   UpperLeft.y  = rClientRect.top;
   ClientToScreen (hWnd, (LPPOINT) & UpperLeft);

   LowerRight.x = rClientRect.bottom;
   LowerRight.y = rClientRect.right / 2;
   ClientToScreen (hWnd, (LPPOINT) & LowerRight);

   rClientRect.left   = UpperLeft.x;
   rClientRect.top    = UpperLeft.y;
   rClientRect.bottom = LowerRight.x;
   rClientRect.right  = LowerRight.y;

   ClipCursor ( (LPRECT) & rClientRect);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   switch (message)
     {
   case WM_DESTROY:
 /*** release the cursor (a shared resource) to the rest of the system ***/
     ClipCursor ( (LPRECT)NULL);
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, message, wParam, lParam);
     break;
     }
   return (0L);
   }


 CLIPDATA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPDATA.C

 /*
  *  This program demonstrates the use of GetClipboardData function.
  *  This function retieves data from the clipboard in the format given by
  *  an unsigned short interger value that specifies a data format. The
  *  clipboard must have been previously opened.
  *
  */

 #include <windows.h>

 static char  szAppName[] = "clipdata";
 static char     szFuncName[] = "GetClipboardData";

 LPSTR FAR PASCAL lstrcpy (LPSTR, LPSTR);

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   HMENU    hMenu;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Read From Clipboard", 100, MF_APPEND);

   hWnd = CreateWindow (szAppName,            /* window class name       */
                       szFuncName,            /* window caption          */
                       WS_OVERLAPPEDWINDOW,   /* window style            */
                       CW_USEDEFAULT,         /* initial x position      */
                       0,                     /* initial y position      */
                       CW_USEDEFAULT,         /* initial x size          */
                       0,                     /* initial y size          */
                       NULL,                  /* parent window handle    */
                       hMenu,                 /* window menu handle      */
                       hInstance,             /* program instance handle */
                       NULL);                 /* create parameters       */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU  hMenu;
   HANDLE hClipData;
   HANDLE hMem;
   LPSTR  lpText;
   char  szBuffer[80];

   switch (iMessage)
     {
     case WM_CREATE:
       OpenClipboard (hWnd);
       hMem = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT,
                          (long) strlen (szFuncName));
       lpText = (LPSTR) GlobalLock (hMem);
       lstrcpy (lpText, (LPSTR) szFuncName);
       SetClipboardData (CF_TEXT, hMem);
       GlobalUnlock (hMem);
       CloseClipboard ();

     case WM_COMMAND:
       if (wParam == 100)
         {
         OpenClipboard (hWnd);
         MessageBox (hWnd, (LPSTR)"Getting clipboard data", (LPSTR)szFuncName,
             MB_OK);
         hClipData = GetClipboardData (CF_TEXT);
         if (hClipData != NULL)
           MessageBox (hWnd, (LPSTR)"Data Received", (LPSTR)szFuncName, MB_OK)
         else
           MessageBox (hWnd, (LPSTR)"There is no data", (LPSTR)szFuncName,
               MB_OK);
         CloseClipboard ();
         }
       break;

     case WM_DESTROY:
       GlobalFree (hMem);        /*  Free up the memory  */
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPEMPT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPEMPT.C

 /*
  *
  *  EmptyClipboard ()
  *
  *  This program demonstrates the use of the EmptyClipboard () function.
  *  This function empties the clipboard and frees handles to data in the
  *  clipboard. It the assigns ownership of the clipboard to the window
  *  that currently has the clipboard open. The clipboard must be open
  *  when EmptyClipboard is called.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon  (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject  (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "clipempt";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Clear Clipboard", 100, MF_APPEND);

   hWnd = CreateWindow ("clipempt",
                       "EmptyClipboard",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU hMenu;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         OpenClipboard (hWnd);
         MessageBox (hWnd, (LPSTR)"Emptying clipboard", (LPSTR)"EmptyClipboard
                     MB_OK);
         if (EmptyClipboard ())  /*  Empty the clipboard  */
           MessageBox (hWnd, (LPSTR)"Clipboard emptied", (LPSTR)"EmptyClipboar
                       MB_OK);
         else
           MessageBox (hWnd, (LPSTR)"Clipboard not emptied",
                      (LPSTR)"EmptyClipboard", MB_OK);
         CloseClipboard  ();
         }
       break;

     case WM_DESTROY:
       PostQuitMessage  (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return  (0L);
   }


 CLIPENUM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPENUM.C

 /*
  *  This program demonstrates the use of EnumClipboardFormats function.
  *  This function numbers a list of formats and returns the next format in
  *  the list.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "clipenum";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow ("clipenum",            /* window class name       */
                       "EnumClipboardFormats",                 /* window capti
                       WS_OVERLAPPEDWINDOW,        /* window style
                       CW_USEDEFAULT,              /* initial x position
                       0,                          /* initial y position
                       CW_USEDEFAULT,              /* initial x size
                       0,                          /* initial y size
                       NULL,                       /* parent window handle
                       NULL,                       /* window menu handle
                       hInstance,                  /* program instance handle
                       NULL);                      /* create parameters

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU hMenu;
   int  nNextFormat;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Number Formats", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         MessageBox (NULL, (LPSTR)"Getting first format in list",
                    (LPSTR)"EnumClipboardFormats", MB_OK);
         nNextFormat = EnumClipboardFormats (0);
         if (nNextFormat == 0)
           MessageBox (NULL, (LPSTR)"First format returned",
                      (LPSTR)"EnumClipboardFormats", MB_OK);
         else
           MessageBox (NULL, (LPSTR)"First format not returned",
                      (LPSTR)"EnumClipboardFormats", MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPFORM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPFORM.C

 /*
  *   This program demonstrates the use of the IsClipboardFormatAvailable
  *   function. IsClipboardFormatAvailable checks to see if the given
  *   data format is available in the clipboard. In this sample application,
  *   the format checked for in the clipboard is CF_BITMAP. IsClipboardFormat-
  *   Available is called from WinMain in this sample application. To test
  *   the function, bring up Paint and this application at the same time.
  *   If you cut anything from Paint, it goes to the clipboard and IsClipboard
  *   FormatAvailable should return TRUE. If there is no bitmap in the clipboa
  *   then IsClipBoardFormatAvailable should return FALSE. Using Paint, once
  *   you have put a bitmap in the clipboard, there will be a bitmap format
  *   in the clipboard until your windows session is ended.
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  wndclass;
   MSG       msg;
   HMENU     hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = "CLIPFORM";

     if (!RegisterClass (&wndclass))
       return FALSE;
     }
   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Format", 100, MF_APPEND);

   hWnd = CreateWindow ("CLIPFORM",
                       "IsClipboardFormatAvailable",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (int)msg.wParam;
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   BOOL  bFormat;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         bFormat = IsClipboardFormatAvailable (CF_BITMAP);
         if (bFormat)
           MessageBox (hWnd, (LPSTR)"There IS a bitmap format available",
                      (LPSTR)"IsClipboardFormatAvailable", MB_OK);
         else
           MessageBox (hWnd, (LPSTR)"There is NOT a bitmap format available",
                      (LPSTR)"IsClipboardFormatAvailable", MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CLIPFORN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPFORN.C

 /*
  *
  *  GetClipboardFormatName
  *
  *  clipforn.c, charlesl, v2.00, 29-Dec-1987
  *
  *  This program demonstrates the use of GetClipboardFormatName function.
  *  This function retrieves from the clipboard the name of the register
  *  format specified by an unsigned short integer. The name is copied to
  *  the buffer pointed to by long pointer.
  *
  *  Other references: CFClip.c
  *
  *  Microsoft Product Support Services
  *  Windows Version 2.0 function demonstration application
  *  Copyright (c) Microsoft 1987
  *
  */

 /*************************************************************************/
 /*                           INCLUDE FILES                               */
 /*************************************************************************/

 #include <windows.h>

 /*************************************************************************/
 /*                        STRUCTURE DEFINTIONS                           */
 /*************************************************************************/

 typedef struct
 {
    int nDummy;
 }
 SETUPDATA;

 /*************************************************************************/
 /*                         GLOBAL VARIABLES                              */
 /*************************************************************************/

 static SETUPDATA strSetUpData;
 static HANDLE hInst;
 static char szFileName[] = "clipforn";
 static char szFuncName[] = "GetClipboardFormatName";

 /*************************************************************************/
 /*                       FORWARD REFERENCES                              */
 /*************************************************************************/

 long FAR PASCAL WindowProc ( HANDLE , unsigned , WORD , LONG );

 /*************************************************************************/
 /*                         MAIN PROCEDURE                                */
 /*************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow );

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }
   exit(msg.wParam);
 }

 /*************************************************************************/
 /*                      INITIALIZATION                                   */
 /*************************************************************************/

 BOOL WindowInit (hInstance , hPrevInstance , cmdShow)
 HANDLE hInstance, hPrevInstance;
 int cmdShow;
 {
   HWND  hWnd;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.lpfnWndProc   = WindowProc;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;
      rClass.hInstance     = hInstance;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.lpszMenuName  = (LPSTR) NULL;
      rClass.lpszClassName = (LPSTR) szFileName;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }
   else
      GetInstanceData ( hPrevInstance, (PSTR) &strSetUpData,
         sizeof ( SETUPDATA ) );

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) szFileName, (LPSTR) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) NULL,
                       (HANDLE) hInstance, (LPSTR) NULL );

   ShowWindow ( hWnd , cmdShow );
   UpdateWindow (hWnd);

   return TRUE;
 }

 /*************************************************************************/
 /*                 WINDOW PROCEDURE - PROCESS MESSAGES                   */
 /*************************************************************************/

 long FAR PASCAL WindowProc (hWnd , message , wParam , lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         FunctionDemonstrated ( hWnd );
         EndPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage ( 0 );
         break;

     default:
         return ( DefWindowProc ( hWnd , message , wParam , lParam ) );
         break;
     }
   return ( 0L );
 }

 /*************************************************************************/
 /*              FUNCTION DEMONSTRATED HERE - LOOK HERE                   */
 /*************************************************************************/

 FunctionDemonstrated ( hWnd )
 HWND hWnd;
 {
   WORD wFormat;
   int nCopied;
   LPSTR lpFormatName;

   MessageBox (NULL, (LPSTR)"Getting clipboard format name",
      (LPSTR)szFuncName, MB_OK);

   wFormat = RegisterClipboardFormat ( (LPSTR)"format_name" );
   nCopied = GetClipboardFormatName ( wFormat, lpFormatName, 20 );

   if ( nCopied != 0 )
       MessageBox (NULL, (LPSTR)"Format name gotten", (LPSTR)szFuncName,
          MB_OK);
   else
       MessageBox (NULL, (LPSTR)"Format does not exits", (LPSTR)szFuncName,
          MB_OK);

   return TRUE;
 }



 CLIPOPEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPOPEN.C

 /*
  *  OpenClipboard
  *  This program demonstrates the use of the OpenClipboard function.
  *  This function opens the clipboard for examination and prevents other
  *  applications from modifying the clipboard contents.
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) "clipopen";

     if (!RegisterClass (&rClass))
       return FALSE;
     }
   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Open Clipboard", 100, MF_APPEND);

   hWnd = CreateWindow ("clipopen",
                       "OpenClipboard",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   BOOL  bOpened;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         MessageBox (NULL, (LPSTR)"Open a clipboard", (LPSTR)"OpenClipboard",
                     MB_OK);
         bOpened = OpenClipboard (hWnd);
         if (bOpened)
           MessageBox (NULL, (LPSTR)"Clipboard is open", (LPSTR)"OpenClipboard
                       MB_OK);
         else
           MessageBox (NULL, (LPSTR)"Clipboard is not open",
                      (LPSTR)"OpenClipboard", MB_OK);
         CloseClipboard ();
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPOWN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPOWN.C

 /*
  *
  *  clipown.c
  *
  *  This program demonstrates the use of the GetClipboardOwner functions.
  *  This function retrieves the window handle of the current ower of clip-
  *  board.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "clipown";

     if (!RegisterClass (&rClass))
       return FALSE;
     }
   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Clipboard Owner", 100, MF_APPEND);

   hWnd = CreateWindow ("clipown",
                       "GetClipboardOwner",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HWND  hClipWnd;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         MessageBox (NULL, (LPSTR)"Getting clipboard owner",
                     (LPSTR)"GetClipboardOwner", MB_OK);
         hClipWnd = GetClipboardOwner ();
         if (hClipWnd)
           MessageBox (NULL, (LPSTR)"Clipboard has an owner",
                      (LPSTR)"GetClipboardOwner", MB_OK);
         else
           MessageBox (NULL, (LPSTR)"Clipboard does not has an owner",
                      (LPSTR)"GetClipboardOwner", MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPREG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPREG.C

 /*
  *
  *  RegisterClipboardFormat
  *
  *  This program demonstrates the use of RegisterClipboardFormat function.
  *  This function registers a new clipboard format whose name is pointed to
  *  by a long pionter to a character string naming the new format. The
  *  registered format can be used in subsequent clipboard functions as valid
  *  format in which to render data, and it will appear in th clipboard's list
  *  of formats.
  */

 /*************************************************************************/
 /*                           INCLUDE FILES                               */
 /*************************************************************************/

 #include <windows.h>

 /*************************************************************************/
 /*                        STRUCTURE DEFINTIONS                           */
 /*************************************************************************/

 typedef struct
 {
    int nDummy;
 }
 SETUPDATA;

 /*************************************************************************/
 /*                         GLOBAL VARIABLES                              */
 /*************************************************************************/

 static SETUPDATA strSetUpData;
 static HANDLE hInst;
 static char szFileName[] = "clipreg";
 static char szFuncName[] = "RegisterClipboardFormat";

 /*************************************************************************/
 /*                       FORWARD REFERENCES                              */
 /*************************************************************************/

 long FAR PASCAL WindowProc ( HANDLE , unsigned , WORD , LONG );

 /*************************************************************************/
 /*                         MAIN PROCEDURE                                */
 /*************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow );

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }
   exit(msg.wParam);
 }

 /*************************************************************************/
 /*                      INITIALIZATION                                   */
 /*************************************************************************/

 BOOL WindowInit (hInstance , hPrevInstance , cmdShow)
 HANDLE hInstance, hPrevInstance;
 int cmdShow;
 {
   HWND  hWnd;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.lpfnWndProc   = WindowProc;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;
      rClass.hInstance     = hInstance;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.lpszMenuName  = (LPSTR) NULL;
      rClass.lpszClassName = (LPSTR) szFileName;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }
   else
      GetInstanceData ( hPrevInstance, (PSTR) &strSetUpData,
         sizeof ( SETUPDATA ) );

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) szFileName, (LPSTR) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) NULL,
                       (HANDLE) hInstance, (LPSTR) NULL );

   ShowWindow ( hWnd , cmdShow );
   UpdateWindow (hWnd);

   return TRUE;
 }

 /*************************************************************************/
 /*                 WINDOW PROCEDURE - PROCESS MESSAGES                   */
 /*************************************************************************/

 long FAR PASCAL WindowProc (hWnd , message , wParam , lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         FunctionDemonstrated ( hWnd );
         EndPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage ( 0 );
         break;

     default:
         return ( DefWindowProc ( hWnd , message , wParam , lParam ) );
         break;
     }
   return ( 0L );
 }

 /*************************************************************************/
 /*              FUNCTION DEMONSTRATED HERE - LOOK HERE                   */
 /*************************************************************************/

 FunctionDemonstrated ( hWnd )
 HWND hWnd;
 {
   WORD wFormat;

   MessageBox (NULL, (LPSTR)"Register clipboard format", (LPSTR)szFuncName,
      MB_OK);

   wFormat = RegisterClipboardFormat ( (LPSTR)"format_name");

   if ( wFormat != 0 )
       MessageBox (NULL, (LPSTR)"Format registered", (LPSTR)szFuncName, MB_OK)
   else
       MessageBox (NULL, (LPSTR)"Format can not be registered",
          (LPSTR)szFuncName, MB_OK);

   return TRUE;
 }


 CLIPSET.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPSET.C

 /*
  *
  *  SetClipboardData
  *
  *  This program demonstrates the use of the SetClipboardData function.
  *  This function sets a data handle into the clipboard for the data
  *  specified by the second parameter. The data is assumed to have the
  *  format specified by the frist parameter. After the clipboard data
  *  handle has been assigned, this function frees the block indentified
  *  by the second parameter.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 int     strlen (char *);

 LPSTR FAR PASCAL lstrcpy (LPSTR, LPSTR);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "clipset";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Set Data", 100, MF_APPEND);

   hWnd = CreateWindow ("clipset",
                       "SetClipboardData",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HANDLE hClipData;
   HANDLE hMem;
   LPSTR  lpText;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         OpenClipboard (hWnd);
         hMem = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT,
                            (long) strlen ("SetClipboardData"));
         lpText = (LPSTR) GlobalLock (hMem);
         lstrcpy (lpText, "SetClipboardData");
         EmptyClipboard ();
         MessageBox (hWnd, (LPSTR)"Setting handle to clipboard",
                     (LPSTR)"SetClipboardData", MB_OK);
         hClipData = SetClipboardData (CF_TEXT, hMem);
         if (hClipData != NULL)
           MessageBox (hWnd, (LPSTR)"Handle set", (LPSTR)"SetClipboardData",
                       MB_OK);
         else
           MessageBox (hWnd, (LPSTR)"Handle not set", (LPSTR)"SetClipboardData
                       MB_OK);
         CloseClipboard ();
         GlobalUnlock (hMem);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPVG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPVG.C

 /*
  *
  *  GetClipboardViewer
  *
  *  clipvg.c
  *
  *  This program demonstrates the use of GetClipboardViewer function.
  *  This funtion retrieves the window handle of the first window in the
  *  clipboard viewer chain.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "clipvg";

     if (!RegisterClass (&rClass))
       return FALSE;
     }
   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Retrieve", 100, MF_APPEND);

   hWnd = CreateWindow ("clipvg",
                       "GetClipboardViewer",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND       hWnd;
 unsigned   iMessage;
 WORD       wParam;
 LONG       lParam;
   {
   HWND  hWndViewChain;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         SetClipboardViewer (hWnd);
         MessageBox (hWnd,
                     "Retreving frist window in clipboard viewer message chain
                     "GetClipboardViewer", MB_OK);
         hWndViewChain = GetClipboardViewer ();
         if (hWndViewChain)
           MessageBox (hWnd, "Got the frist window in the message chain",
                       "GetClipboardViewer", MB_OK);
         else
           MessageBox (hWnd, "No window in the message chain",
                       "GetClipboardViewer", MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLIPVS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\CLIPVS.C

 /*
  *
  *  SetClipboardViewer
  *
  *  clipvs.c
  *
  *  This program demonstrates the use of the SetClipboardViewer function.
  *  This function adds the window specified by handle to the window to the
  *  chain of windows that are notifed whenever the contents of the clipboard
  *  have changed.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) "clipvs";

     if (!RegisterClass (&rClass))
       return FALSE;
     }
   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, (LPSTR)"Add", 100, MF_APPEND);

   hWnd = CreateWindow ("clipvs",
                       "SetClipBoardViewer",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       hMenu,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HWND  hWndNext;

   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         MessageBox (NULL, (LPSTR)"Add window to clipboard message chain",
                    (LPSTR)"SetClipBoardViewer", MB_OK);
         hWndNext = SetClipboardViewer (hWnd);
         if (hWnd == GetClipboardViewer ())
           MessageBox (NULL, (LPSTR)"Window added the message chain",
                      (LPSTR)"SetClipBoardViewer", MB_OK);
         else
           MessageBox (NULL, (LPSTR)"Window not added the message chain",
                      (LPSTR)"SetClipBoardViewer", MB_OK);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 CLOSECOM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\CLOSECOM.C

 /*
  *
  *  CloseComm
  *
  *  This program demonstrates the use of the function CloseComm.
  *  This function closes the communication device specified by the
  *  parameter and frees any memory allocated for the device's transmit
  *  and receive queues. All characters in the output queue are sent
  *  before the communication device is closed.
  *
  *  Other references: CFDial.c
  */

 /*************************************************************************/
 /*                           INCLUDE FILES                               */
 /*************************************************************************/

 #include <windows.h>

 /*************************************************************************/
 /*                        STRUCTURE DEFINTIONS                           */
 /*************************************************************************/

 typedef struct
 {
    int nDummy;
 }
 SETUPDATA;

 /*************************************************************************/
 /*                         GLOBAL VARIABLES                              */
 /*************************************************************************/

 static SETUPDATA strSetUpData;
 static HANDLE hInst;
 static char szFileName[] = "closecom";
 static char szFuncName[] = "CloseComm";

 /*************************************************************************/
 /*                       FORWARD REFERENCES                              */
 /*************************************************************************/

 long FAR PASCAL WindowProc ( HANDLE , unsigned , WORD , LONG );

 /*************************************************************************/
 /*                         MAIN PROCEDURE                                */
 /*************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow );

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }
   exit(msg.wParam);
 }

 /*************************************************************************/
 /*                      INITIALIZATION                                   */
 /*************************************************************************/

 BOOL WindowInit (hInstance , hPrevInstance , cmdShow)
 HANDLE hInstance, hPrevInstance;
 int cmdShow;
 {
   HWND  hWnd;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.lpfnWndProc   = WindowProc;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;
      rClass.hInstance     = hInstance;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.lpszMenuName  = (LPSTR) NULL;
      rClass.lpszClassName = (LPSTR) szFileName;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }
   else
      GetInstanceData ( hPrevInstance, (PSTR) &strSetUpData,
         sizeof ( SETUPDATA ) );

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) szFileName, (LPSTR) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) NULL,
                       (HANDLE) hInstance, (LPSTR) NULL );

   ShowWindow ( hWnd , cmdShow );
   UpdateWindow (hWnd);

   return TRUE;
 }

 /*************************************************************************/
 /*                 WINDOW PROCEDURE - PROCESS MESSAGES                   */
 /*************************************************************************/

 long FAR PASCAL WindowProc (hWnd , message , wParam , lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         FunctionDemonstrated ( );
         EndPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage ( 0 );
         break;

     default:
         return ( DefWindowProc ( hWnd , message , wParam , lParam ) );
         break;
     }
   return ( 0L );
 }

 /*************************************************************************/
 /*              FUNCTION DEMONSTRATED HERE - LOOK HERE                   */
 /*************************************************************************/

 FunctionDemonstrated ( )
 {
   int nCid;
   int nResult;

   nCid = OpenComm ( ( LPSTR ) "LPT1", 255, 256 );

   MessageBox ( NULL, ( LPSTR ) "Closing LPT1", ( LPSTR ) szFuncName, MB_OK );

   nResult = CloseComm ( nCid );

   if ( nResult == 0 )
      MessageBox (NULL, (LPSTR)"LPT1 closed", (LPSTR)szFuncName, MB_OK);
   else
      MessageBox (NULL, (LPSTR)"LPT1 not closed", (LPSTR)szFuncName, MB_OK);

   return TRUE;
 }


 CLOSESND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\CLOSESND.C

 /*
  *  Function Name:   CloseSound
  *  Program Name:    CloseSnd.c
  *
  *  Description:
  *   CloseSound closes access to the play device and frees the device for
  *   opening by other applications.  the CloseSound function flushes all
  *   voice queues and frees any buffers allocated for these queues.
  */

 #include "windows.h"
 #include "stdio.h"

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CloseSound (hWnd)
 HWND hWnd;

 {
   char  szBuffer[30];
   short  nVoices; /* Specifies the number of voices available. */

   nVoices = OpenSound (); /* Opens access to play device, locks it from  */
 /* further users, returns the number of voices */
 /* available.                                  */

   if (nVoices == S_SERDVNA)
     MessageBox (NULL, (LPSTR) "Play device in use.", (LPSTR) "Error", MB_OK);
   else if (nVoices == S_SEROFM)
     MessageBox (NULL, (LPSTR) "Insufficient memory available.",
         (LPSTR) "Error\0", MB_OK);
   else
   {
     sprintf (szBuffer, "%d voice (s) are available.", nVoices);
     MessageBox (NULL, (LPSTR) szBuffer,
         (LPSTR)"Mission Accomplished\0", MB_OK);

     CloseSound ();    /* Closesnd closes the play device, allowing other */
 /* applications to use the device.                 */
   }
   if ( (nVoices != S_SEROFM) && (nVoices != S_SERDVNA))
   {
     MessageBox (NULL, (LPSTR)"CloseSound complete, device available.",
         (LPSTR)"Mission Accomplished\0", MB_OK);
   }
   else
   {
     MessageBox (NULL, (LPSTR)"Device unavailable, try later",
         (LPSTR)"Mission Failed", MB_OK);

   }

   return;
 }


 /**************************************************************************/

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   CALL_CloseSound (hWnd);
   return 0;
 }




 CLOSEWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\CLOSEWIN.C

 /*
  *
  * Function (s) demonstrated in this program: CloseWindow
  *
  * Description:  This function makes a window iconic
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "CloseWin.h"

 HWND     hWndMain;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];

 struct   {
   char  *szMessage;
   } Messages [] =   {
   "About\0",
   "     This is a sample application to demonstrate the\n\
 use of the CloseWindow Windows function.",

   "Help Message",
   "     This program uses the CloseWindow Windows\n\
 function to minimize this window, the window is\n\
 then restored to its original state.  Use the menu\n\
 to test this function.",

   };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
   {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
   }

 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int     nCmdShow;
   {
   static char   szAppName [] = "CloseWin";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

 hWndMain = CreateWindow (szAppName,        /* window class name       */
                         "CloseWindow",              /* window caption
                         WS_OVERLAPPEDWINDOW,        /* window style
                         CW_USEDEFAULT,              /* initial x position
                         0,                          /* initial y position
                         CW_USEDEFAULT,              /* initial x size
                         0,                          /* initial y size
                         NULL,                       /* parent window handle
                         NULL,                       /* window menu handle
                         hInstance,                  /* program instance handl
                         NULL);                     /* create parameters

   ShowWindow (hWndMain, nCmdShow);
   UpdateWindow (hWndMain);

   hInstMain = hInstance;

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU       hMenu;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           ProcessMessage (hWnd, 0);
           break;
         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_CLOSEWINDOW:
           MessageBox (hWnd, "About to Use CloseWindow", "CloseWindow", MB_OK)
           CloseWindow (hWnd);
           MessageBox (hWnd, "Restoring window to original state",
                       "CloseWindow", MB_OK);
           SendMessage (hWnd, WM_SYSCOMMAND, SC_RESTORE, 0L);
           break;

         case IDM_HELP:
           ProcessMessage (hWnd, 2);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 CMETAFIL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\CMETAFIL.C

 /*
  *  This program demonstrates the use of the function CloseMetaFile.
  *  This function closes the metafile DC and creates a metafile handle
  *  that can be used to play the metafile using PlayMetaFile.
  *
  */

 #include <windows.h>

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 static char  szAppName[] = "cmetafil";
 static char  szFuncName[] = "CloseMetaFile";

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
   {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = szAppName;

     if (!RegisterClass (&rClass))
       return TRUE;
   }

 hWnd = CreateWindow (szAppName,            /* window class name       */
 szFuncName,                 /* window caption          */
 WS_OVERLAPPEDWINDOW,        /* window style            */
 CW_USEDEFAULT,              /* initial x position      */
 0,                          /* initial y position      */
 CW_USEDEFAULT,              /* initial x size          */
 0,                          /* initial y size          */
 NULL,                       /* parent window handle    */
 NULL,                       /* window menu handle      */
 hInstance,                  /* program instance handle */
   NULL);                      /* create parameters       */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
   {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
   }
   return (msg.wParam);
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   HANDLE hMF;
   HDC    hDCMeta;
   HDC    hDC;
   HMENU  hMenu;
   BOOL   bPlayed;

   switch (iMessage)
   {
   case WM_CREATE:
     hMenu = CreateMenu ();
     ChangeMenu (hMenu, NULL, (LPSTR)"Play", 100, MF_APPEND);
     SetMenu (hWnd, hMenu);
     break;
   case WM_INITMENU:
     InvalidateRect (hWnd, NULL, TRUE);
     break;
   case WM_COMMAND:
     if (wParam == 100)
     {
       hDC = GetDC (hWnd);
       hDCMeta = CreateMetaFile ((LPSTR)"CMETAFIL.MET");
       Rectangle (hDCMeta, 10, 10, 600, 200);
       Arc (hDCMeta, 10, 10, 600, 200, 10, 15, 600, 150);
       MessageBox (GetFocus(), (LPSTR)"Creating handle to metafile",
           (LPSTR) szFuncName, MB_OK);
       hMF = CloseMetaFile (hDCMeta);
       if (hMF != NULL)
       {
   MessageBox (GetFocus(), (LPSTR)"Metafile handle created",
       (LPSTR) szFuncName, MB_OK);
   bPlayed = PlayMetaFile (hDC, hMF);
   MessageBox (GetFocus(), (LPSTR)"This is the metafile",
       (LPSTR) szFuncName, MB_OK);
       }
       else
   MessageBox (GetFocus(), (LPSTR)"Metafile handle not created",
       (LPSTR) szFuncName, MB_OK);
       DeleteMetaFile (hMF);
       ReleaseDC (hWnd, hDC);
     }
     break;
   case WM_DESTROY:
     PostQuitMessage (0);
     break;
   default:
     return DefWindowProc (hWnd, iMessage, wParam, lParam);
   }
   return (0L);
 }




 COPYRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\COPYRECT.C

 /*
  * Function (s) demonstrated in this program: CopyRect
  *
  * Description:  This function copies the contents of one rectangle structure
  *     into another.
  *
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <math.h>

 char  szRadius  [15];
 HANDLE  hInstMain;
 HWND    hWndMain;

 long FAR PASCAL WndProc                (HWND, unsigned, WORD, LONG);
 void            DrawSquare             (HDC, RECT);

 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  nCmdShow;
   {
   static char  szAppName[] = "CopyRect";
   HWND  hWnd;
   MSG   msg;
   WNDCLASS  wndclass;

   if (!hPrevInstance)
     {
     wndclass.style          = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc    = WndProc;
     wndclass.cbClsExtra     = 0;
     wndclass.cbWndExtra     = 0;
     wndclass.hInstance      = hInstance;
     wndclass.hIcon          = NULL; /*LoadIcon (NULL, IDI_ASTERISK);*/
     wndclass.hCursor        = LoadCursor (NULL, IDC_CROSS);
     wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName  = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }
   hWnd = CreateWindow (szAppName, "CopyRect",
                       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0, NULL, NULL,
                       hInstance, NULL);

   hInstMain = hInstance;
   hWndMain  = hWnd;

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }


 /****************************************************************************

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned    iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   static RECT   Rect1, Rect2;
   HDC          hDC;
   PAINTSTRUCT   ps;
   int   xOffset, yOffset;

   switch (iMessage)
     {
     case WM_CREATE:
       SetRectEmpty (&Rect1);
       SetRectEmpty (&Rect2);

       Rect1.top = 10;
       Rect1.left = 15;
       Rect1.right = 30;
       Rect1.bottom = 20;
       break;

     case WM_PAINT:
       SetRectEmpty (&Rect1);
       SetRectEmpty (&Rect2);
       Rect1.top = 10;
       Rect1.left = 15;
       Rect1.right = 30;
       Rect1.bottom = 20;

       hDC = BeginPaint (hWnd, &ps);
       CopyRect (&Rect2, &Rect1);      /*  Copy the contents of Rect1
                                        *  to Rect2  */

       for (xOffset = 0; xOffset < 15; xOffset++)
         {
         Rect1.top += 10;
         Rect1.left += 15;
         Rect1.bottom += 11;
         Rect1.right += 17;
         DrawSquare (hDC, Rect1);
         }
       DrawSquare (hDC, Rect2);
       EndPaint (hWnd, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return 0L;
   }


 /***************************************************************************/

 void DrawSquare (hDC, rect)
 HDC       hDC;
 RECT      rect;
   {
   MoveTo (hDC, rect.left,  rect.top);
   LineTo (hDC, rect.right, rect.top);
   LineTo (hDC, rect.right, rect.bottom);
   LineTo (hDC, rect.left,  rect.bottom);
   LineTo (hDC, rect.left,  rect.top);
   }


 CPMETAFI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\CPMETAFI.C

 /*
  *  CopyMetaFile
  *  This program demonstrates the use of the function CopyMetaFile.
  *  This function copied the source metafile to the file named by second
  *  parameter and returns a handle to the new metafile.
  */

 #include <windows.h>

 static HANDLE hWnd;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
   {
   static char  szFuncName[] = "CopyMetaFile";
   HANDLE hMF;
   HANDLE hMF2;

   hMF = GetMetaFile ( (LPSTR) "CPMETAFI.MET");

   MessageBox (NULL, (LPSTR)"Coping metafile", (LPSTR) szFuncName, MB_OK);

   hMF2 = CopyMetaFile (hMF, (LPSTR) "METAFILE");

   if (hMF2 != NULL)
     MessageBox (NULL, (LPSTR)"Copied", (LPSTR) szFuncName, MB_OK);
   else
     MessageBox (NULL, (LPSTR)"Not copied", (LPSTR) szFuncName, MB_OK);

   return 0;
   }


 CRBITMAP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRBITMAP.C

 #include <windows.h>
 #include "crbitmap.h"

 HANDLE hInst;
 HBITMAP hBitmap;                    /* bitmap structure handle */

 short nBlobBitmap[] = {
         0x0000, 0x0000,
         0x0000, 0x0000,
         0x000f, 0xf000,
         0x000f, 0xf000,
         0x00ff, 0xff00,
         0x00ff, 0xff00,
         0x0fff, 0xfff0,
         0x0fff, 0xfff0,
         0x0ff0, 0x0ff0,
         0x0ff0, 0x0ff0,
         0xfff0, 0x0fff,
         0xfff0, 0x0fff,
         0xff00, 0x00ff,
         0xff00, 0x00ff,
         0xffff, 0xffff,
         0xffff, 0xffff};

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;       /* current instance */
 HANDLE hPrevInstance;   /* previous instance */
 LPSTR lpCmdLine;        /* command line */
 int nCmdShow;           /* show window type (open/icon) */
 {
     HWND hWnd;          /* window handle */
     MSG msg;            /* message */
     HMENU hMenu;        /* handle to the menu */

     if  (!hPrevInstance)        /* app already initialized? */
         if (!CreateBitMapInit(hInstance))       /* nope, init it */
             return(NULL);               /* couldn't init */

     hInst = hInstance;          /* store the current instance */

     hWnd = CreateWindow("CreateBitMap", /* window class */
         "CreateBitMap Sample Application",      /* window name */
         WS_OVERLAPPEDWINDOW,            /* window style */
         CW_USEDEFAULT,                  /* x position */
         CW_USEDEFAULT,                  /* y position */
         CW_USEDEFAULT,                  /* width */
         CW_USEDEFAULT,                  /* height */
         NULL,                           /* parent handle */
         NULL,                           /* menu or child */
         hInstance,                      /* instance */
         NULL);                          /* additional info */

     if (!hWnd)                  /* did we get a valid handle? */
         return(NULL);           /* nope, couldn't open window */

     ShowWindow(hWnd, nCmdShow);         /* show the window */
     UpdateWindow(hWnd);                 /* send the WM_PAINT msg */

     while (GetMessage(&msg, NULL, NULL, NULL))
     {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
     }
     return(msg.wParam);         /* return value from PostQuitMessage */
 }

 /* register the window */
 BOOL CreateBitMapInit(hInstance)
 HANDLE hInstance; /* current instance */
 {
     HANDLE hMemory;             /* handle to allocated memory */
     PWNDCLASS pWndClass;        /* structure pointer */
     BOOL bSuccess;              /* saves RegisterClass status */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->lpszClassName = (LPSTR)  "CreateBitMap";
     pWndClass->hInstance = hInstance;
     pWndClass->lpfnWndProc = CreateBitMapWndProc;
     pWndClass->style = NULL;
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->lpszMenuName = (LPSTR) NULL;

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);               /* unlock the memory */
     LocalFree(hMemory);                 /* return it to windows */

     return (bSuccess);
 }

 /* process messages to the window */

 long FAR PASCAL CreateBitMapWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                              /* window handle */
 unsigned message;                       /* type of message */
 WORD wParam;                            /* additional information */
 LONG lParam;                            /* additional information */
 {
     FARPROC lpProcAbout;                /* pointer to "About" procedure */
     HMENU hMenu;                        /* menu handle */
     HDC hMemoryDC;                      /* memory device context */
     HDC hDC;                            /* display device context */
     HANDLE hOldObject;                  /* return code from SelectObject */

     switch (message)
     {
         case WM_CREATE :                /* add command to system menu */
             hMenu = GetSystemMenu(hWnd, FALSE);
             ChangeMenu(hMenu, NULL, NULL, NULL,
                 MF_APPEND | MF_SEPARATOR);
             ChangeMenu(hMenu, NULL, "A&bout CreateBitMap...",
             ID_ABOUT, MF_APPEND | MF_STRING);
             /* create bitmap */
             hBitmap = CreateBitmap(32, 16, 1, 1, (LPSTR)nBlobBitmap);
             if (hBitmap == NULL)
                 MessageBox(NULL, (LPSTR)"Error creating Bitmap",
                            NULL, IDOK);
             break;

         case WM_SYSCOMMAND :
             switch (wParam)
             {
                 case ID_ABOUT:
                     lpProcAbout = MakeProcInstance(About, hInst);
                     DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
                     FreeProcInstance(lpProcAbout);
                     break;

                 default:
                     return(DefWindowProc(hWnd, message, wParam, lParam));
             }
             break;

         case WM_PAINT:
             hDC = GetDC(hWnd);
             hMemoryDC = CreateCompatibleDC(hDC);
             hOldObject = SelectObject(hMemoryDC, hBitmap);
             if (hOldObject == NULL)
                 MessageBox(NULL, (LPSTR)"Error selecting object",
                            NULL, IDOK);
             BitBlt(hDC, 50, 30, 32, 16, hMemoryDC, 0, 0, SRCCOPY);
             /* clean up */
             SelectObject(hMemoryDC, hOldObject);
             DeleteDC(hMemoryDC);
             ReleaseDC(hWnd, hDC);
             break;

         case WM_DESTROY:                /* quit application */
       DeleteObject(hBitmap);  /* delete bitmap */
             PostQuitMessage(NULL);      /* notify windows */
             break;

         default:                        /* pass it on if unprocessed */
             return(DefWindowProc(hWnd, message, wParam, lParam));
     }
     return(NULL);
 }

 /* this function handles the "About" box */

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;                       /* type of message */
 WORD wParam;                            /* additional information */
 LONG lParam;                            /* additional information */
 {
     switch (message)
     {
         case WM_INITDIALOG:             /* init dialog box */
             return(TRUE);               /* don't need to do anything */
         case WM_COMMAND:                /* received a command */
             if (wParam == IDOK)         /* OK box selected? */
             {
                 EndDialog (hDlg, NULL);         /* then exit */
                 return(TRUE);
             }
             break;
     }
     return(FALSE);                      /* didn't process a message */
 }


 CRCARET.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\CRCARET.C

 /*
  *  This program will demonstrate the use of the CreateCaret function.
  *  It will define a new shape for the system caret and give ownership
  *  of the system caret to the current window.
  *
  */

 #include <windows.h>
 #include "crcaret.h"

 HANDLE hInst;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 LPSTR   lpCmdLine;
 int     nCmdShow;
   {
   HWND hWnd;    /* window handle */
   MSG msg;      /* message */
   HMENU hMenu;  /* handle to the menu */

   if (!hPrevInstance)   /* app already initialized? */
     if (!CrCaretInit (hInstance))        /* nope, init it */
       return (NULL);             /* couldn't init */

   hInst = hInstance;    /* store the current instance */

   hWnd = CreateWindow ("CrCaret",  /* window class */
                       "CreateCaret Sample Application", /* window name */
                       WS_OVERLAPPEDWINDOW,              /* window style */
                       CW_USEDEFAULT,                    /* x position */
                       CW_USEDEFAULT,                    /* y position */
                       CW_USEDEFAULT,                    /* width */
                       CW_USEDEFAULT,                    /* height */
                       NULL,                             /* parent handle */
                       NULL,                             /* menu or child */
                       hInstance,                        /* instance */
                       NULL);                            /* additional info */

   if (!hWnd)
     return (NULL);

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

   while (GetMessage (&msg, NULL, NULL, NULL))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 /* register the window */
 BOOL CrCaretInit (hInstance)
 HANDLE hInstance; /* current instance */
   {
   HANDLE hMemory;
   PWNDCLASS pWndClass;
   BOOL bSuccess;

   hMemory = LocalAlloc (LPTR, sizeof (WNDCLASS));
   pWndClass = (PWNDCLASS) LocalLock (hMemory);

   pWndClass->lpszClassName = (LPSTR)  "CrCaret";
   pWndClass->hInstance = hInstance;
   pWndClass->lpfnWndProc = CrCaretWndProc;
   pWndClass->style = NULL;
   pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH);
   pWndClass->hCursor = LoadCursor (NULL, IDC_ARROW);
   pWndClass->hIcon = LoadIcon (NULL, IDI_APPLICATION);
   pWndClass->lpszMenuName = (LPSTR) NULL;

   bSuccess = RegisterClass (pWndClass);

   LocalUnlock (hMemory);
   LocalFree (hMemory);

   return (bSuccess);
   }


 /* process messages to the window */

 long    FAR PASCAL CrCaretWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;        /* window handle */
 unsigned  message;      /* type of message */
 WORD wParam;        /* additional information */
 LONG lParam;        /* additional information */
   {
   FARPROC lpProcAbout;    /* pointer to "About" procedure */
   HMENU hMenu;      /* menu handle */

   switch (message)
     {
     case WM_CREATE :
           /* add command to system menu */
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, NULL, NULL, MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, "A&bout CreateCaret...",
                   ID_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND :
       switch (wParam)
         {
         case ID_ABOUT:
           lpProcAbout = MakeProcInstance (About, hInst);
           DialogBox (hInst, "AboutBox", hWnd, lpProcAbout);
           FreeProcInstance (lpProcAbout);
           break;

         default:
           return (DefWindowProc (hWnd, message, wParam, lParam));
         }
       break;

     case WM_SETFOCUS:             /* create and show caret */
       CreateCaret (hWnd, NULL, 0, 5);
       SetCaretPos (20, 20);
       ShowCaret (hWnd);
       break;

     case WM_KILLFOCUS:            /* destroy the caret */
       DestroyCaret ();
       break;

     case WM_DESTROY:              /* quit application */
       PostQuitMessage (NULL);      /* notify windows */
       break;

     default:                      /* pass it on if unprocessed */
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (NULL);
   }


 /* this function handles the "About" box */

 BOOL FAR PASCAL About (hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;      /* type of message */
 WORD wParam;        /* additional information */
 LONG lParam;        /* additional information */
   {
   switch (message)
     {
     case WM_INITDIALOG:           /* init dialog box */
       return (TRUE);               /* don't need to do anything */
     case WM_COMMAND:              /* received a command */
       if (wParam == IDOK)         /* OK box selected? */
         {
         EndDialog (hDlg, NULL);           /* then exit */
         return (TRUE);
         }
       break;
     }
   return (FALSE);                        /* didn't process a message */
   }


 CRDIAIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\CRDIAIN.C

 /*
  *
  *  CreateDialogIndirect
  *
  *  This program demonstrates the use of the function CreateDialogIndirect.
  *  It allows a user to create a modeless dialogbox on the fly. Memory for th
  *  structure is dynamcally allocated to conform to variable string lengths.
  */

 #include <windows.h>
 #include "crdiain.h"

 BOOL FAR PASCAL InitDiabox (HANDLE, HANDLE, int);
 long  FAR PASCAL DiaboxWindowProc (HANDLE, unsigned, WORD, LONG);
 BOOL FAR PASCAL DialogBoxWindowProc (HANDLE, unsigned, WORD, LONG);

 HANDLE hInst;
 FARPROC lpDlgTest;
 HWND hDlgTest;

 typedef struct dtHdrType {
   LONG  dtStyle;
   BYTE  dtItemCount;
   int  dtX;
   int  dtY;
   int  dtCX;
   int  dtCY;
   char  dtResourceName[1];
   char  dtClassName[1];
   char  dtCaptionText[1];
 } DTHDR;

 typedef struct dtItmType {
   int  dtilX;
   int  dtilY;
   int  dtilCX;
   int  dtilCY;
   int  dtilID;
   LONG  dtilWindowStyle;
   BYTE  dtilControlClass;
   char  dtilText[1];
 } DTITM;


 /**************************************************************************/

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;

   InitDiabox (hInstance, hPrevInstance, cmdShow);
   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
   {
     if ( (hDlgTest == NULL) || !IsDialogMessage (hDlgTest, (LPMSG) & msg))
     {
       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
     }
   }
   exit (msg.wParam);
 }


 /*******************************   initialization   ***********************/

 BOOL FAR PASCAL InitDiabox (hInstance, hPrevInstance, cmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 int  cmdShow;
 {
   WNDCLASS  wcDiaboxClass;
   HWND  hWnd;

   wcDiaboxClass.lpszClassName = (LPSTR) "Diabox";
   wcDiaboxClass.hInstance     = hInstance;
   wcDiaboxClass.lpfnWndProc   = DiaboxWindowProc;
   wcDiaboxClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcDiaboxClass.hIcon         = NULL;
   wcDiaboxClass.lpszMenuName  = (LPSTR) "diabox";
   wcDiaboxClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcDiaboxClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcDiaboxClass.cbClsExtra    = 0;
   wcDiaboxClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcDiaboxClass);
   hWnd = CreateWindow ( (LPSTR) "Diabox",
       (LPSTR) "CreateDialogIndirect",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,
       (HMENU)NULL,
       (HANDLE)hInstance,
       (LPSTR)NULL);

   hInst = hInstance;                    /*  instance saved for dialog box  */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
 }


 /*********************   window procedure - process messages   *************/

 long  FAR PASCAL DiaboxWindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned  message;
 WORD        wParam;
 LONG        lParam;
 {
   switch (message)
   {
   case WM_COMMAND:
     switch (wParam)
     {
     case IDDBOX:
       DisplayDialogBox (hWnd);
       break;
     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return (DefWindowProc (hWnd, message, wParam, lParam));
     break;
   }
   return (0L);
 }


 /***************************************************************************/

 DisplayDialogBox (hWnd)
 HWND   hWnd;
 {
   DTHDR    dtHdr;
   DTITM    dtItm;
   HANDLE   hDTemplate;
   LPSTR    lpDTemplate;
   WORD     wByteCount;
   BYTE     work[256];

   if (hDlgTest != NULL)
     return (FALSE);

   if (!(hDTemplate = GlobalAlloc (GMEM_MOVEABLE, (DWORD) sizeof (DTHDR))))
     return (FALSE);
   wByteCount = 0;

   dtHdr.dtStyle     = WS_POPUP | WS_VISIBLE | WS_BORDER | WS_CAPTION;
   dtHdr.dtItemCount = 2;
   dtHdr.dtX         = 10;
   dtHdr.dtY         = 10;
   dtHdr.dtCX        = 200;
   dtHdr.dtCY        = 100;
   dtHdr.dtResourceName[0] = 0;
   dtHdr.dtClassName[0]    = 0;
   if (!writeGMem (hDTemplate, wByteCount, (BYTE * ) & dtHdr, sizeof (DTHDR) -
     return (FALSE);
   wByteCount += sizeof (DTHDR) - 1;

   strcpy (work, "Howdy !!!");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

 /* add BUTTON item */

   dtItm.dtilX     = 30;
   dtItm.dtilY     = 50;
   dtItm.dtilCX    = 32;
   dtItm.dtilCY    = 12;
   dtItm.dtilID    = 0x0200;
   dtItm.dtilWindowStyle = BS_DEFPUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIB
   dtItm.dtilControlClass = 0x80;
   if (!writeGMem (hDTemplate, wByteCount, (BYTE * ) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   strcpy (work, "OK");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);
   wByteCount += 1;

 /* add MESSAGE item */

   dtItm.dtilX     = 30;
   dtItm.dtilY     = 20;
   dtItm.dtilCX    = 100;
   dtItm.dtilCY    = 8;
   dtItm.dtilID    = 0x0100;
   dtItm.dtilWindowStyle = SS_LEFT | WS_CHILD | WS_VISIBLE;
   dtItm.dtilControlClass = 0x82;
   if (!writeGMem (hDTemplate, wByteCount, (BYTE * ) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   strcpy (work, "Modeless DialogBox");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);

   lpDlgTest = MakeProcInstance ( (FARPROC) DialogBoxWindowProc, hInst);

   lpDTemplate = GlobalLock (hDTemplate);
 /*  function demonstrated  */
   hDlgTest = CreateDialogIndirect (hInst, lpDTemplate, hWnd, lpDlgTest);

   if (hDlgTest == -1)
     MessageBox (NULL, (LPSTR)"CreateDialogIndirect failed",
         (LPSTR)"error", MB_ICONHAND);
   GlobalUnlock (hDTemplate);

   return (TRUE);
 }


 /**************************************************************************/

 BOOL FAR PASCAL DialogBoxWindowProc (hDlg, message, wParam, lParam)
 HWND      hDlg;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
 {
   switch (message)
   {
   case WM_COMMAND:
     switch (wParam)
     {
     case 0x0100:
     case 0x0200:
       break;
     default:
       return (TRUE);
     }
     break;
   default:
     return (FALSE);
   }

   DestroyWindow (hDlgTest);
   hDlgTest = NULL;
   return (TRUE);
 }


 /****************************************************************************

 BOOL NEAR writeGMem (hData, offset, data, length)
 HANDLE  hData;
 WORD    offset;
 BYTE    *data;
 WORD    length;
 {
   HANDLE  hNewData;
   LPSTR   lpDstData;
   int  n;

   if (offset + length > GlobalSize (hData))
   {
     if (!(hNewData = GlobalReAlloc (hData, (DWORD) offset + length, GMEM_MOVE
       GlobalFree (hData);

     hData = hNewData;
   }

   if (lpDstData = GlobalLock (hData))
   {
     lpDstData = lpDstData + offset;
     for (n = 0; n < length; n++)
       *lpDstData++ = *data++;
     GlobalUnlock (hData);
     return (TRUE);
   }

   return (FALSE);
 }




 CRDISBIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRDISBIT.C

 /*
  *  CreateDiscardableBitmap
  */

 #include "windows.h"

 static HWND  hWnd;
 static RECT  rect;

 void    ExecuteTest ();

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance;
 HANDLE    hPrevInstance;
 LPSTR    lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;

   if (!hPrevInstance)
   {
 /* ensure that windows know where to find parts of this
      * task on disk by Registering a window class.  Registering
                  * a class binds an executable name to an internal name,
      * known to Windows. */
     WNDCLASS  rClass;

     rClass.lpszClassName         = (LPSTR)"CreateDiscardableBitmap";
     rClass.hInstance   = hInstance;
     rClass.lpfnWndProc   = DefWindowProc;
     rClass.hCursor               = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon                 = LoadIcon (hInstance, (LPSTR)"CreateDiscard
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.hbrBackground         = GetStockObject (WHITE_BRUSH);
     rClass.style     = CS_HREDRAW | CS_VREDRAW;
     rClass.cbClsExtra   = 0;
     rClass.cbWndExtra   = 0;

     RegisterClass ( (LPWNDCLASS) & rClass);
   } /* end if this is the 1st task/instance of this program */

   hWnd = CreateWindow ( (LPSTR) "CreateDiscardableBitmap", /* Window class na
   (LPSTR) "CreateDiscardableBitmap", /* Window title */
   WS_OVERLAPPEDWINDOW,
     /* stlye -- WIN 2.x or later */
 CW_USEDEFAULT,  /* x -  WIN 2.x or later */
 CW_USEDEFAULT,  /* y -  WIN 2.x or later */
 CW_USEDEFAULT,  /* cx - WIN 2.x or later */
 CW_USEDEFAULT,  /* cy - WIN 2.x or later */
   (HWND)NULL,   /* No parent */
   (HMENU)NULL,  /* Use the class menu */
   (HANDLE)hInstance, /* .EXE file for Class */
   (LPSTR)NULL   /* No Params */
   );
   ShowWindow (hWnd, cmdShow);     /* Allocate room for window     */
   UpdateWindow (hWnd);            /* Paint the client area        */

   MessageBox (hWnd, (LPSTR) "Beginning Test", (LPSTR) " ", MB_OK);

 /* The actual test of the CreateDiscardableBitmap function  */
   ExecuteTest (hWnd);

   MessageBox (hWnd, (LPSTR) "Demonstration Finished", (LPSTR) " ", MB_OK);
   return 0L;
 } /* WINMAIN */


 /****************************************************************************
 /* This is the function to test CreateDiscardableBitmap Function.         */

 void ExecuteTest (hWnd)
 HWND hWnd;
 {
   HDC    hDC;
   HDC    hMemoryDC;        /* handle to In-memory display Context */
   HBITMAP   hBitmap;          /* handle to Bitmap  */
   HBITMAP   hOldBitmap;
   BITMAP  bm;            /* copy of bitmap    */
   short  xStart;
   short  yStart;
   POINT    pt;            /* structure of x-y coordinates */

 /* prepare and create bitmap  */
   hDC = GetDC (hWnd);
   hMemoryDC = CreateCompatibleDC (hDC);
   hBitmap = CreateDiscardableBitmap (hDC, 64, 32);
   hOldBitmap = SelectObject (hMemoryDC, hBitmap);

 /* Color with Black  */
   PatBlt (hMemoryDC, 0, 0, 64, 32, BLACKNESS);

   GetObject (hBitmap, sizeof (BITMAP), (LPSTR) & bm);
   pt.x = bm.bmWidth;
   pt.y = bm.bmHeight;
   DPtoLP (hDC, &pt, 1);          /* convert to logical units for GDI */

   xStart = yStart = 0;

 /* Copy to the Display Context  */
   BitBlt (hDC, xStart, yStart, pt.x, pt.y, hMemoryDC, 0, 0, SRCCOPY);

 /* Discard objects and free up memory */
   DeleteDC (hMemoryDC);
   ReleaseDC (hWnd, hDC);
   return;
 } /* END EXECUTETEST */


 /* END DISCARD.C */


 CREATBRI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CREATBRI.C

 /*
  *   This program demonstrates the use of the CreateBrushIndirect () function
  *   CreateBrushIndirect () returns a handle to a brush with characteristics
  *   described by a LOGBRUSH structure. CreateBrushIndirect () is called in
  *   response to a WM_CREATE message in HelloWndProc (). The brush is used
  *   to fill a rectangle in response to a WM_PAINT message.
  *
  */

 #include    <windows.h>
 HBRUSH      hMyBrush;
 LOGBRUSH    lbBrushStyle;
 RECT        MyRect;

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName     = (LPSTR)"CreateBrushIndirect";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   HelloInit (hInstance);
   hWnd = CreateWindow ( (LPSTR)"CreateBrushIndirect",
                       (LPSTR)"CreateBrushIndirect ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL );       /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_CREATE:
           /*  initialize the LOGBRUSH structure "lbBrushStyle  */
       lbBrushStyle.lbStyle = BS_HATCHED;
       lbBrushStyle.lbColor = RGB (0x00, 0x00, 0x00);
       lbBrushStyle.lbHatch = HS_BDIAGONAL;
           /* initialize the rectangle structure "MyRect" */
       MyRect.left   =  17;
       MyRect.top    =  17;
       MyRect.right  = 300;
       MyRect.bottom = 100;
           /*** create a hatched brush described by lbBrushStyle ***/
       hMyBrush = CreateBrushIndirect ( (LPLOGBRUSH) & lbBrushStyle);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       TextOut (ps.hdc, 5, 5,
               (LPSTR)"This rectangle filled with hatched brush created via Cr
               (long)74);
       FillRect (ps.hdc, (LPRECT) & MyRect, hMyBrush);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CREATDLG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\CREATDLG.C

 /*
  *   This program demonstrates use of the CreateDialog () function.
  *   CreateDialog () creates a modeless dialog box. CreateDialog () is
  *   called in response to a WM_COMMAND message in HelloWndProc ();
  */

 #include "windows.h"
 #include "creatdlg.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);
 BOOL    FAR PASCAL ShakeOptions (HWND, unsigned, WORD, LONG);
 HWND    hYourTurnDlg = NULL;
 HANDLE  hInst;
 HWND    hWnd;
 FARPROC lpprocSHAKE;

 BOOL FAR PASCAL ShakeOptions (hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   HWND hCtl;
   int  i;
   BOOL OKAY;
   HDC hDC;
   RECT ClearRect;

   switch (message)
     {
     case WM_INITDIALOG:
       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDOK:
           DestroyWindow (hYourTurnDlg);
           hYourTurnDlg = NULL;
           break;

         default:
           return FALSE;
           break;
         } /** end CASE WM_COMMAND **/
       break;

     case WM_DESTROY:
       return TRUE;
       break;

     default:
       return FALSE;
     }
   }

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));
   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = NULL;
   pHelloClass->lpszMenuName   = (LPSTR)"hello";
   pHelloClass->lpszClassName  = (LPSTR)"CreateDialog";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);

   return TRUE;        /* Initialization succeeded */
   }


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;

   int   i;

   if (!hPrevInstance)
     if (!HelloInit (hInstance))
       return FALSE;

   hWnd = CreateWindow ( (LPSTR)"CreateDialog",
                       (LPSTR)"CreateDialog ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   hInst = hInstance;

   lpprocSHAKE  = MakeProcInstance ( (FARPROC)ShakeOptions, hInstance);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     if (hYourTurnDlg == NULL || !IsDialogMessage (hYourTurnDlg, &msg))
       {
       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
       }
     }

   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
          /*** if the dialog box does not currently exist ***/
       if (!hYourTurnDlg)
         hYourTurnDlg = CreateDialog (hInst, MAKEINTRESOURCE (5), hWnd, lpproc
          /*** create the dialog box and assign "hYourTurnDlg" to its handle *
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CREATFON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\CREATFON.C

 /*
  *
  * Function (s) demonstrated in this program: CreateFont, CreateFontIndirect,
  *      CreateBitmapIndirect, CreateCompatibleBitmap, SetBitmapBits,
  *      GetBitmapBits, SetBitmapBits.
  *
  * Description:
  * This application demonstrates the GetBitmapBits, SetBitmapBits,
  * CreateBitmapIndirect, CreateFont, CreateCompatibleBitmap,
  * CreateFontIndirect, and SetBitmapBits Windows functions.
  *
  */

 #include <windows.h>
 #include <string.h>
 #include <stdio.h>
 #include "CreatFon.h"

 long  FAR PASCAL WndProc  (HWND, unsigned, WORD, LONG);
 HBITMAP StretchBitmap (HBITMAP, int);
 HBITMAP GetBitmapFont (int);

 long  dwCount;
 HBITMAP  hBitmapScottie;
 PBITMAP  pBitmap;
 char  nBits[500] = "ABC";
 HBITMAP  hBitmapPopFont;
 HBITMAP  hBitmapAbout;
 HANDLE   hInstMain;
 char  szAppName [] = "CreatFon";
 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];

 struct {
   char  *szMessage;
 } Messages [] =   {
   "About\0",
   "  This application demonstrates the GetBitmapBits, \n\
 SetBitmapBits, CreateBitmapIndirect, CreateFont, \n\
 CreateCompatibleBitmap, CreateFontIndirect, and\n\
 SetBitmapBits Windows functions.",

       "Help Message",
   "     This program demonstrates the use of many\n\
 Windows functions.  Use the menu to test these\n\
 functions.",

   "CreateFont",
   "     The menu has a new item the font for which\n\
 was created using the CreateFont Windows function.",

   "CreateFontIndirect",
   "     The menu has a new item the font for which\n\
 was created using the CreateFontIndirect Windows\n\
 function.",

   "CreateBitmapIndirect",
   "     The menu has a new item the bitmap for which\n\
 was created using the CreateBitmapIndirect Windows\n\
 function.",

       "CreateCompatibleBitmap",
   "     The menu has a new item the bitmap for which\n\
 was created using the CreateCompatibleBitmap Windows\n\
 function.",

       "GetBitmapBits",
   "    Bitmap bits are stored in a buffer.",

   "SetBitmapBits",
   "     The menu has a new item the bitmap for which\n\
 was created using the SetBitmapBits Windows\n\
 function.",

   "SetBitmapBits",
   "     You must Get the Bits first!",

 };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)  /*  For outputting messages  */
 HWND     hWnd;
 int  MessageNumber;
 {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }


 /****************************************************************************

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int  nCmdShow;
 {
   HMENU    hMenu, hMenuPopup;
   HWND     hWnd;
   MSG      msg;
   int  i;
   WNDCLASS wndclass;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
   }

   hInstMain = hInstance;

   hWnd = CreateWindow (szAppName, "Bitmap Menu Demonstration",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   hMenu = GetSystemMenu (hWnd, FALSE);
   hBitmapAbout = StretchBitmap (LoadBitmap (hInstance, "BitmapAbout"), 1);
   ChangeMenu (hMenu, NULL, NULL, 0, MF_APPEND | MF_SEPARATOR);
   ChangeMenu (hMenu, NULL, (PSTR) hBitmapAbout, IDM_ABOUT,
       MF_APPEND | MF_BITMAP);

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

   while (GetMessage (&msg, NULL, 0, 0))
   {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
   }

   DeleteObject (hBitmapPopFont);  /*  Free up memory taken by bitmaps  */
   DeleteObject (hBitmapAbout);
   DeleteObject (hBitmapScottie);

   return msg.wParam;
 }


 /****************************************************************************

 HBITMAP StretchBitmap (hBitmap1, I)
 HBITMAP    hBitmap1;
 int  I;
 {
   BITMAP     bm1, bm2;
   HBITMAP    hBitmap2;
   HDC        hDC, hMemDC1, hMemDC2;
   TEXTMETRIC tm;

   hDC = CreateIC ("DISPLAY", NULL, NULL, NULL);
   GetTextMetrics (hDC, &tm);
   hMemDC1 = CreateCompatibleDC (hDC);
   hMemDC2 = CreateCompatibleDC (hDC);
   DeleteDC (hDC);

   GetObject (hBitmap1, sizeof (BITMAP), (LPSTR) & bm1);

   bm2 = bm1;
   bm2.bmWidth      = (tm.tmAveCharWidth * bm2.bmWidth)  / 4;
   bm2.bmHeight     = (tm.tmHeight       * bm2.bmHeight) / 8;
   bm2.bmWidthBytes = ( (bm2.bmWidth + 15) / 16) * 2;

   if (I == 1)
   {
     hBitmap2 = CreateBitmapIndirect (&bm2);
     SelectObject (hMemDC1, hBitmap1);
     SelectObject (hMemDC2, hBitmap2);
   }
   else
   {
     SelectObject (hMemDC1, hBitmap1);
     hBitmap2 = CreateCompatibleBitmap (hMemDC1, bm2.bmWidth, bm2.bmHeight);
     SelectObject (hMemDC2, hBitmap2);
   }

   StretchBlt (hMemDC2, 0, 0, bm2.bmWidth, bm2.bmHeight,
       hMemDC1, 0, 0, bm1.bmWidth, bm1.bmHeight, SRCCOPY);

   DeleteDC (hMemDC1);
   DeleteDC (hMemDC2);
   DeleteObject (hBitmap1);

   return hBitmap2;
 }


 /****************************************************************************

 HBITMAP GetBitmapFont (i)
 int  i;
 {
   static struct
   {
     BYTE lfPitchAndFamily;
     BYTE lfFaceName [LF_FACESIZE];
     char  *szMenuText;
   } lfSet [2] =
   {
     VARIABLE_PITCH | FF_ROMAN,  "Tms Rmn",   "Times Roman",
     VARIABLE_PITCH | FF_SWISS,  "Helvetica", "Helvetica"
   };
   DWORD   dwSize;
   HBITMAP hBitmap;
   HDC     hDC, hMemDC;
   HFONT   hFont, hNewFont;
   LOGFONT lf;

   hFont = GetStockObject (SYSTEM_FONT);
   GetObject (hFont, sizeof (LOGFONT), (LPSTR) & lf);

   lf.lfHeight *= 2;
   lf.lfWidth  *= 2;
   lf.lfPitchAndFamily = lfSet[i].lfPitchAndFamily;
   strcpy (lf.lfFaceName, lfSet[i].lfFaceName);

   hDC = CreateIC ("DISPLAY", NULL, NULL, NULL);
   hMemDC = CreateCompatibleDC (hDC);

   if (i == 0)
   {
     hNewFont = CreateFont (lf.lfHeight, lf.lfWidth, lf.lfEscapement,
         lf.lfOrientation, lf.lfWeight, lf.lfItalic,
         lf.lfUnderline, lf.lfStrikeOut, lf.lfCharSet,
         lf.lfOutPrecision, lf.lfClipPrecision, lf.lfQuality,
         lf.lfPitchAndFamily, lf.lfFaceName);
     SelectObject (hMemDC, hNewFont);
   }
   else
     SelectObject (hMemDC, CreateFontIndirect (&lf));

   dwSize = GetTextExtent (hMemDC, lfSet[i].szMenuText,
       strlen (lfSet[i].szMenuText));

   hBitmap = CreateBitmap (LOWORD (dwSize), HIWORD (dwSize), 1, 1, NULL);
   SelectObject (hMemDC, hBitmap);
   TextOut (hMemDC, 0, 0, lfSet[i].szMenuText, strlen (lfSet[i].szMenuText));

   DeleteObject (SelectObject (hMemDC, hFont));
   DeleteDC (hMemDC);
   DeleteDC (hDC);

   return hBitmap;
 }


 /****************************************************************************

 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   HMENU    hMenu;
   static short  nCurrentFont = IDM_TMSRMN;

   switch (iMessage)
   {
   case WM_SYSCOMMAND:
     switch (wParam)
     {
     case IDM_ABOUT:
       ProcessMessage (hWnd, 0);
       break;
     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
     break;

   case WM_COMMAND:
     switch (wParam)
     {
     case IDM_CREATEFONT:
       hMenu = GetSubMenu (GetMenu (hWnd), 0);
       hBitmapPopFont = GetBitmapFont (0);
       ChangeMenu (hMenu, NULL, NULL, 0,
           MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, (PSTR) hBitmapPopFont,
           IDM_TMSRMN, MF_APPEND | MF_BITMAP);
       ProcessMessage (hWnd, 4);
       break;

     case IDM_CREATEFONTINDIRECT:
       hMenu = GetSubMenu (GetMenu (hWnd), 0);
       hBitmapPopFont = GetBitmapFont (1);
       ChangeMenu (hMenu, NULL, NULL, 0,
           MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, (PSTR) hBitmapPopFont,
           IDM_TMSRMN, MF_APPEND | MF_BITMAP);
       ProcessMessage (hWnd, 6);
       break;

     case IDM_CREATEBMPINDIRECT:
       hMenu = GetSubMenu (GetMenu (hWnd), 0);
       hBitmapAbout = StretchBitmap (LoadBitmap (hInstMain,
           "BitmapAbout"), 1);
       ChangeMenu (hMenu, NULL, NULL, 0,
           MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, (PSTR) hBitmapAbout,
           IDM_ABOUT, MF_APPEND | MF_BITMAP);
       ProcessMessage (hWnd, 8);
       break;

     case IDM_CREATECOMPATIBLEBMP:
       hMenu = GetSubMenu (GetMenu (hWnd), 0);
       hBitmapAbout = StretchBitmap (LoadBitmap (hInstMain,
           "BitmapAbout"), 2);
       ChangeMenu (hMenu, NULL, NULL, 0,
           MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, (PSTR) hBitmapAbout,
           IDM_ABOUT, MF_APPEND | MF_BITMAP);
       ProcessMessage (hWnd, 10);
       break;

     case IDM_GETBITMAPBITS:
       hBitmapScottie = LoadBitmap (hInstMain,
           "BitmapScottie");
       pBitmap = (PBITMAP)LocalAlloc (LMEM_MOVEABLE,
           sizeof (BITMAP));
       dwCount = GetObject (hBitmapScottie,
           (long)sizeof (BITMAP), (LPSTR) pBitmap);
       if (GetBitmapBits (hBitmapScottie, dwCount,
           (LPSTR)nBits))
   ProcessMessage (hWnd, 12);
       else
   MessageBox (hWnd, "Bitmap did not copy!",
       "GetBitmapBits", MB_OK);
       break;

     case IDM_SETBITMAPBITS:
       if (nBits [0] == 'A')
   ProcessMessage (hWnd, 16);
       else
       {
   SetBitmapBits (hBitmapScottie, dwCount, nBits);
   hMenu = GetSubMenu (GetMenu (hWnd), 0);
   hBitmapScottie = StretchBitmap (hBitmapScottie, 1);
   ChangeMenu (hMenu, NULL, NULL, 0,
       MF_APPEND | MF_SEPARATOR);
   ChangeMenu (hMenu, NULL, (PSTR) hBitmapScottie,
       IDM_SCOTTIE, MF_APPEND | MF_BITMAP);
   ProcessMessage (hWnd, 14);
       }
       break;

     case IDM_HELP:
       ProcessMessage (hWnd, 2);
       break;
     }
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, iMessage, wParam, lParam);
   }
   return 0L;
 }




 CRELIPRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRELIPRG.C

 /*
  *  Function Name:   CreateEllipticRgn
  *
  *  Description:
  *   The program below will create an elliptical region which will be
  *   inverted so that it can be seen.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateEllipticRgn (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   HRGN hNewRgn;
   RECT ClientRect;

   GetClientRect (hWnd, (LPRECT) & ClientRect);       /* get client area */

   hNewRgn = CreateEllipticRgn (10, 10, (short) (ClientRect.right / 2),
                                (short) (ClientRect.bottom / 2));
   if (hNewRgn == NULL)
     {
     MessageBeep(0);    /*  Beep if we have an error  */
     return;
     }
   InvertRgn (hDC, hNewRgn);
   DeleteObject (hNewRgn);

   return;
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateEllipticRgn";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreateEllipticRgn",
                       (LPSTR)"CreateEllipticRgn ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       CALL_CreateEllipticRgn (hWnd, ps.hdc);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CRELIRIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRELIRIN.C

 /*
  *  Function Name:   CreateEllipticRgnIndirect
  *
  *  Description:
  *   The program below creates an elliptical region that will be displayed
  *   by inverting the region.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateEllipticRgnIndirect (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   RECT ClientRect;
   HRGN hNewRgn;

   GetClientRect (hWnd, (LPRECT) & ClientRect);   /* get client area  */

   ClientRect.right /= 2;
 /* create new region   */
   hNewRgn = CreateEllipticRgnIndirect ( (LPRECT) & ClientRect);

   if (hNewRgn == NULL)                   /* Check for error */
     {
     MessageBeep (0);
     return;
     }
   InvertRgn (hDC, hNewRgn);
   DeleteObject (hNewRgn);
   return;
   }

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateEllipticRgnIndirect";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreateEllipticRgnIndirect",
                       (LPSTR)"CreateEllipticRgnIndirect ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */


   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       CALL_CreateEllipticRgnIndirect (hWnd, ps.hdc);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CREWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\CREWIN.C

 /*
  *  CreateWindow
  *  This function demonstrates the use of the CreateWindow function.  It will
  *  create a window using the CreateWindow function, show the window using
  *  the ShowWindow command and procede to draw a triangle in the window in
  *  the MM_ANISOTROPIC mapping mode.
  */

 #include <windows.h>

 BOOL FAR PASCAL InitCreateWindow (HANDLE, HANDLE, int);
 long    FAR PASCAL CreateWindowWindowProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      nCmdShow;
   {
   MSG  msg;

   InitCreateWindow (hInstance, hPrevInstance, nCmdShow);  /*  Init Routine  *
   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   exit (msg.wParam);
   }


 BOOL FAR PASCAL InitCreateWindow (hInstance, hPrevInstance, nCmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 int      nCmdShow;
   {
   WNDCLASS  wcCreateWindowClass;
   HWND  hWnd;

   wcCreateWindowClass.lpszClassName = (LPSTR) "CreateWindow";
   wcCreateWindowClass.hInstance     = hInstance;
   wcCreateWindowClass.lpfnWndProc   = CreateWindowWindowProc;
   wcCreateWindowClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcCreateWindowClass.hIcon      = NULL;
   wcCreateWindowClass.lpszMenuName  = (LPSTR) NULL;
   wcCreateWindowClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcCreateWindowClass.style      = CS_HREDRAW | CS_VREDRAW;
   wcCreateWindowClass.cbClsExtra    = 0;
   wcCreateWindowClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcCreateWindowClass);

   hWnd = CreateWindow ( (LPSTR) "CreateWindow",  /*  Window class name
                       (LPSTR) "CreateWindow",    /*  Window title
                       WS_OVERLAPPEDWINDOW,       /*  Type of window
                       CW_USEDEFAULT,             /*  default x pos
                       CW_USEDEFAULT,             /*  default y pos
                       CW_USEDEFAULT,             /*  default change in x pos
                       CW_USEDEFAULT,             /*  default change in y pos
                       (HWND)NULL,                /*  No parent for this wind
                       (HMENU)NULL,               /*  Use the Class menu
                       (HANDLE)hInstance,         /*  Who created this window
                       (LPSTR)NULL);              /*  No params. to pass on.

   ShowWindow (hWnd, nCmdShow);   /*  Display this window on the screen
                                    *  nCmdShow is passed in by WinMain, and
            *  should only be used with ShowWindow
            *  once during a program.  Any further
            *  calls to ShowWindow will need to have
            *  certain values.  See entry in manual
            *  for ShowWindow for further details
              */

   UpdateWindow (hWnd);           /*  Cause a paint message              */
   return TRUE;
   }

 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long    FAR PASCAL CreateWindowWindowProc (hWnd, message, wParam, lParam)

 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   switch (message)
     {
     case WM_PAINT:
       PaintCreateWindowWindow (hWnd);
       break;

     case WM_DESTROY:                  /*  If close requested      */
       PostQuitMessage (0);     /*    send yourself a quit  */
       break;                          /*    message               */

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }


 /*
  *  THE PAINT PROCEDURE
  */

 PaintCreateWindowWindow (hWnd)

 HWND    hWnd;
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE        hOldBrush, hBrush;
   RECT          rRect;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);    /*  Prepare the client area  */
   hDC = ps.hdc;             /*  Get the Display Context  */

   hBrush = GetStockObject (GRAY_BRUSH);     /*  Get a gray brush         */
   hOldBrush = SelectObject (hDC, hBrush);  /*  Select the new brush     */

   lpTriangle[0].x = 150;    /*  The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode (hDC, MM_ANISOTROPIC);   /*  Set the mapping mode             */

   SetWindowExt (hDC, 300, 300);      /*  Set the extent of the drawing
                                       *  area.  This is the area that
                                       *  holds graphics that you create
                                       *  with GDI functions.  Do not
                                       *  confuse this function with
                                       *  the actual window.  The
                                       *  SetViewportExt sets the
                                       *  extent of the area to be mapped
                                       *  to which is the actual window
                                       */

   GetClientRect (hWnd, (LPRECT) & rRect);
                                          /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt (hDC, rRect.right, rRect.bottom);
 /*  Set the Extent of the viewport   */

   Polygon (hDC, lpTriangle, 3);      /*  Draw the triangle                */

   ValidateRect (hWnd, (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   SelectObject (hDC, hOldBrush);       /*  Replace the old brush  */
   return TRUE;
   }


 CRHABRUS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRHABRUS.C

 /*
  *  Function Name:   CreateHatchBrush
  *
  *  Description:
  *   This creates a logical brush that can replace the current brush for the
  *   device.  The program below draws a rectangle and fills it in with a red,
  *   vertical line brush that was selected.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 HBRUSH    hBrush;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     hBrush = CreateHatchBrush (HS_VERTICAL, RGB (255, 0, 0));

     if (hBrush == NULL)                /* checks for successful brush creatio
       {
       MessageBox (hWnd, (LPSTR)"CreateHatchBrush failed",
                  (LPSTR)"ERROR", MB_ICONHAND | MB_OK );
       return (0L);
       }

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = hBrush;
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateHatchBrush";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreateHatchBrush",
                       (LPSTR)"CreateHatchBrush ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,         /* no parent */
                       (HMENU)NULL,        /* use class menu */
                       (HANDLE)hInstance,  /* handle to window instance */
                       (LPSTR)NULL);       /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   DeleteObject (hBrush);
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CRIC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRIC.C

 /*
  *  Function Name:   CreateIC
  *  Program Name:    cric.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   An information context is retrieved from the display, and the brush is
  *   extracted.  The brush information for the IC is then displayed on
  *   the screen to show that the IC has valid information.
  */

 #include "windows.h"
 #include "stdio.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateIC(hWnd, hDC)
 HWND hWnd;
 HDC  hDC;
 {
   HDC hIC;
   PLOGBRUSH pBrush;
   HBRUSH  hICBrush;
   char  szstring[80];
   int  nLength;
 /*  information context created   */
   hIC = CreateIC((LPSTR)"DISPLAY", (LPSTR)NULL, (LPSTR)NULL, (LPSTR)NULL);

   if (hIC == NULL)
   {
     MessageBox(hWnd, (LPSTR)"CreateIC failed", (LPSTR)"ERROR", MB_ICONHAND);
     return;
   }

   pBrush = (PLOGBRUSH) LocalAlloc(LMEM_MOVEABLE, sizeof(LOGBRUSH));
   hICBrush = SelectObject(hIC, CreateSolidBrush((LONG)0));
   GetObject(hICBrush, 8, (LPSTR) pBrush);   /* put brush into structure */
   nLength = sprintf(szstring, "Information Context Brush Attributes are:"
       "   style=%u, color=%lx, hatch=%d ",
       pBrush->lbStyle, pBrush->lbColor, pBrush->lbHatch);
   TextOut (hDC, 10, 10, (LPSTR) szstring, nLength);

   return;
 }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon( hInstance, NULL );
   wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"CreateIC";

   if (!RegisterClass( (LPWNDCLASS) & wcClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
   {
 /* Call initialization procedure if this is the first instance */
     if (!WinInit( hInstance ))
       return FALSE;
   }

   hWnd = CreateWindow((LPSTR)"CreateIC",
       (LPSTR)"CreateIC()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_PAINT:
     BeginPaint( hWnd, (LPPAINTSTRUCT) & ps );
     CALL_CreateIC(hWnd, ps.hdc);
     ValidateRect(hWnd, (LPRECT) NULL);
     EndPaint( hWnd, (LPPAINTSTRUCT) & ps );
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 CRMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\CRMENU.C

 /*
  *  Function Name:   CreateMenu
  *
  *  Description:
  *   This program creates a blank menu that the user can fill in from the
  *   program instead of the resource file.  ChangeMenu must be used to enter
  *   the heading and items of the menu.  The program below will add the menu
  *   called "Heading" to the menu bar in CurrentWindowMenu.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateMenu";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, "MenuItem", 100, MF_APPEND);

   hWnd = CreateWindow ( (LPSTR)"CreateMenu",
                       (LPSTR)"CreateMenu ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)hMenu,      /* use our menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 CRMETAFI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\CRMETAFI.C

 /*
  *  Function Name:   CreateMetaFile
  *  Program Name:    crmetafi.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This function is used for saving GDI images on a disk (and in memory)
  *   that can latter be recalled and displayed or printed.  Here a metafile
  *   is created, text is placed in it, and it is written to the disk.
  *   It is then recalled and displayed on the screen.  The recall is either
  *   from memory or disk depending on whether a handle is available to a
  *   memory image.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateMetaFile(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HDC hDCMeta;
   HANDLE hDiskMetaFile;

   hDCMeta = CreateMetaFile((LPSTR) "crmetafi.met");  /* Metafile created */

   if (hDCMeta == NULL)
   {
     MessageBox(hWnd,(LPSTR)"CreateMetaFile failed",(LPSTR)"ERROR",MB_ICONHAND
     return;
   }
   else
     TextOut(hDCMeta, 20, 20, (LPSTR)"Metafile created", 16);

   hDiskMetaFile = CloseMetaFile(hDCMeta);
   PlayMetaFile(hDC, hDiskMetaFile);        /* show metafile  */
   DeleteMetaFile(hDiskMetaFile);

 return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateMetaFile";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"CreateMetaFile",
                         (LPSTR)"CreateMetaFile()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_CreateMetaFile(hWnd, ps.hdc);
         ValidateRect(hWnd, (LPRECT) NULL);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }



 CRPABRUS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRPABRUS.C

 /*
  *  Function Name:   CreatePatternBrush
  *  Program Name:    crpabrus.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This program takes a valid bitmap pattern and assigns it to be used as a
  *   brush.  The program below draws a rectangle and fills it with a
  *   crosshatch pattern brush created from a bitmap.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreatePatternBrush(hWnd, hDC)
 HWND hWnd;
 HDC  hDC;
 {
   HBRUSH    hBrush, hOldBrush;
   HBITMAP   hBitLoad;
 /* set up 8x8 crosshatch pattern */
   static short  BitmapArray[] =
   {
     0xFF, 0xF7, 0xEB, 0xDD, 0xBE, 0x7F, 0xFF, 0xFF    };

   hBitLoad = CreateBitmap(8, 8, 1, 1, (LPSTR)BitmapArray); /* for monochrome

   hBrush = CreatePatternBrush(hBitLoad);      /* load pattern brush    */

   if (hBrush == NULL)                /* checks for successful brush creation
   {
     MessageBox(hWnd, (LPSTR)"CreatePatternBrush failed",
         (LPSTR)"ERROR", MB_ICONHAND);
     return;
   }

   hOldBrush = (HBRUSH) SelectObject (hDC, (HANDLE) hBrush);
   Rectangle (hDC, 10, 10, 300, 100);
   hBrush = SelectObject (hDC, hOldBrush);
   DeleteObject(hBrush);
   DeleteObject(hBitLoad);

   return;
 }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon( hInstance, NULL );
   wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"CreatePatternBrush";

   if (!RegisterClass( (LPWNDCLASS) & wcClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
   {
 /* Call initialization procedure if this is the first instance */
     if (!WinInit( hInstance ))
       return FALSE;
   }

   hWnd = CreateWindow((LPSTR)"CreatePatternBrush",
       (LPSTR)"CreatePatternBrush()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_PAINT:
     BeginPaint( hWnd, (LPPAINTSTRUCT) & ps );
     CALL_CreatePatternBrush(hWnd, ps.hdc);
     ValidateRect(hWnd, (LPRECT) NULL);
     EndPaint( hWnd, (LPPAINTSTRUCT) & ps );
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 CRPEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRPEN.C

 /*
  *  Function Name:   CreatePen
  *
  *  Description:
  *   It creates a logical pen that can replace the current pen for the device
  *   The module below draws an arc.
  *   CreatePen selects the style (0=solid), a width of 20, and the color
  *   red. A width of 0 is one pixel width on raster devices.  The mode used
  *   is MM_TEXT (default).
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/
 void CALL_CreatePen (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   HPEN hPen, hOldPen;

   hPen = CreatePen (0, 20, RGB (255, 0, 0));   /* hPen created.   */

   if (hPen == NULL)                /* checks for successful pen creation */
     {
     MessageBeep(0);
     return;
     }

   hOldPen = (HPEN) SelectObject (hDC, (HANDLE) hPen);
   Arc (hDC, 0, 0, 300, 200, 200, 180, 100, 30);
   DeleteObject (hPen);

   return;
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreatePen";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreatePen",
                       (LPSTR)"CreatePen ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {

   case WM_PAINT:
     BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
     CALL_CreatePen (hWnd, ps.hdc);
     ValidateRect (hWnd, (LPRECT) NULL);
     EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, message, wParam, lParam);
     break;
     }
   return (0L);
   }


 CRPENIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRPENIN.C

 /*
  *  Function Name:   CreatePenIndirect
  *
  *  Description:
  *   This program creates a logical pen that replaces the current pen for the
  *   device.  It uses the data structure LOGPEN to set up the style, width,
  *   and color fields.  With lopnWidth, the data structure is type POINT.
  *   The x value is the width, and the y value is ignored.  Unlike CreatePen,
  *   the structure for LOGOPEN must first be allocated before values can be
  *   assigned.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 HPEN hPen, hOldPen;   /*  Global Handles to Pens  */

 /***********************************************************************/
 void CALL_CreatePenIndirect (hWnd)
 HWND hWnd;
   {
   LOGPEN PenIndirect;
   POINT Point1;

   Point1.x = 10;                      /* assign width 10 to x.          */
   Point1.y = 0;                       /* y is ignored.                  */
   PenIndirect.lopnStyle = 0;         /* style is 0                    */
   PenIndirect.lopnWidth = Point1;      /* width is Point1.         */
   PenIndirect.lopnColor = RGB (255, 0, 0);       /* color is red.   */

   hPen = CreatePenIndirect ( (LPLOGPEN) & PenIndirect);  /*  pen created  */

   if (hPen == NULL)                /* checks for successful pen creation */
     {
     MessageBox (hWnd, (LPSTR)"CreatePenIndirect failed",
                 (LPSTR)"ERROR", MB_ICONHAND | MB_OK);
     DestroyWindow (hWnd);  /*  The pen wasn't created, so trash the program
     return;
     }
   return;
   }


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreatePenIndirect";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreatePenIndirect",
                       (LPSTR)"CreatePenIndirect ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);        /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_CREATE:
       CALL_CreatePenIndirect (hWnd);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       hOldPen = SelectObject (ps.hdc, hPen);
       Arc (ps.hdc, 0, 0, 300, 200, 200, 140, 100, 30);
       SelectObject (ps.hdc, hOldPen);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       DeleteObject (hPen);
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CRPOLYRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRPOLYRG.C

 /*
  *  Function Name:   CreatePolygonRgn
  *
  *  Description:
  *   The program below will create a triangular region and then display it
  *   by inverting the region.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/
 void CALL_CreatePolygonRgn (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   HRGN hNewRgn;
   POINT Points[3];

   Points[0].x = 10;
   Points[0].y = 10;
   Points[1].x = 10;
   Points[1].y = 190;                      /* clip area     */
   Points[2].x = 200;
   Points[2].y = 10;
      /*  polygon region created  */
   hNewRgn = CreatePolygonRgn ( (LPPOINT)Points, 3, WINDING);

   if (hNewRgn == NULL)                   /* Check for error */
     {
     MessageBeep (0);
     return;
     }
   InvertRgn (hDC, hNewRgn);
   DeleteObject (hNewRgn);
   return;
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreatePolygonRgn";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreatePolygonRgn",
                       (LPSTR)"CreatePolygonRgn ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       CALL_CreatePolygonRgn (hWnd, ps.hdc);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CRRECRIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRRECRIN.C

 /*
  *  Function Name:   CreateRectRgnIndirect
  *  Program Name:    crrectin.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below will create a rectangular region and then invert
  *   it to make it visible on the screen.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateRectRgnIndirect(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hNewRgn;
   RECT ClientRect;

   GetClientRect( hWnd, (LPRECT) & ClientRect );   /* get client area */
   ClientRect.right /= 2;             /*  half client area  */
 /* create new region   */
   hNewRgn = CreateRectRgnIndirect((LPRECT) & ClientRect);

   if (hNewRgn == NULL)                   /* Check for error */
   {
     MessageBox(hWnd, (LPSTR)"CreateRectRgn failed.", (LPSTR)"ERROR", MB_ICONH
     return;
   }
   InvertRgn(hDC, hNewRgn);
   DeleteObject( hNewRgn );

   return;
 }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon( hInstance, NULL );
   wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"CreateRectRgnIndirect";

   if (!RegisterClass( (LPWNDCLASS) & wcClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
   {
 /* Call initialization procedure if this is the first instance */
     if (!WinInit( hInstance ))
       return FALSE;
   }

   hWnd = CreateWindow((LPSTR)"CreateRectRgnIndirect",
       (LPSTR)"CreateRectRgnIndirect()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_PAINT:
     BeginPaint( hWnd, (LPPAINTSTRUCT) & ps );
     CALL_CreateRectRgnIndirect(hWnd, ps.hdc);
     ValidateRect(hWnd, (LPRECT) NULL);
     EndPaint( hWnd, (LPPAINTSTRUCT) & ps );
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 CRRECTRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRRECTRG.C

 /*
  *  Function Name:   CreateRectRgn
  *  Program Name:    crrectrg.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below will create a rectagular region and make it visble
  *   by inverting the region.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_CreateRectRgn(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hNewRgn;
   RECT ClientRect;

   GetClientRect( hWnd, (LPRECT) & ClientRect );   /* get client area   */

   hNewRgn = CreateRectRgn(10, 10,
       (short) ClientRect.right / 2,  /* half client area */
   (short) ClientRect.bottom);
   if (hNewRgn == NULL)                   /* Check for error */
   {
     MessageBox(hWnd, (LPSTR)"CreateRectRgn failed.", (LPSTR)"ERROR", MB_ICONH
     return;
   }
   InvertRgn(hDC, hNewRgn);                       /* invert region  */
   DeleteObject( hNewRgn );

   return;
 }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon( hInstance, NULL );
   wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
   wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"CreateRectRgn";

   if (!RegisterClass( (LPWNDCLASS) & wcClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
   {
 /* Call initialization procedure if this is the first instance */
     if (!WinInit( hInstance ))
       return FALSE;
   }

   hWnd = CreateWindow((LPSTR)"CreateRectRgn",
       (LPSTR)"CreateRectRgn()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_PAINT:
     BeginPaint( hWnd, (LPPAINTSTRUCT) & ps );
     CALL_CreateRectRgn(hWnd, ps.hdc);
     ValidateRect(hWnd, (LPRECT) NULL);
     EndPaint( hWnd, (LPPAINTSTRUCT) & ps );
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 CRSOBRUS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\CRSOBRUS.C

 /*
  *  Function Name:   CreateSolidBrush
  *
  *  Description:
  *   This function creates a logical brush that can replace the current brush
  *   for the device.  The program below draws a rectangle and fills it in
  *   with a red brush that was selected.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG     msg;
   HWND    hWnd;
   HBRUSH  hBrush;

   hBrush = CreateSolidBrush (RGB (255, 0, 0));   /* hBrush created (red). */

   if (hBrush == NULL)                /* checks for successful brush creation
     {
     MessageBox (hWnd, (LPSTR)"CreateSolidBrush failed", (LPSTR)"ERROR", MB_IC
     return (0L);
     }

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = hBrush;
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"CreateSolidBrush";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"CreateSolidBrush",
                       (LPSTR)"CreateSolidBrush ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   DeleteObject (hBrush);
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 CWINPROC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\CWINPROC.C

 /*
  *   This program demonstrates the use of the CallWindowProc () function.
  *   CallWindowProc () passes message information contained in the 3rd
  *   parameter to the window identified by the 2nd parameter. CallWindow-
  *   Proc is used in subclassing. This is how it is used in this program.
  *   No real subclass is performed in this program; it is just set up.
  *   Messages destined for the listbox in the dialog box are intercepted
  *   by SubClassProc () and then passed on to the default procedure for
  *   listboxes. CallWindowProc () is called in SubClassProc () after the
  *   subclass is performed.
  */

 #include "windows.h"
 #include "cwinproc.h"

 BOOL FAR PASCAL DialogBoxProc (HWND, unsigned, WORD, LONG);
 long  FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);
 long  FAR PASCAL SubClassProc (HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 FARPROC lpprocDlgProc;
 FARPROC lpprocSubClassProc;
 FARPROC lpprocListBox;

 char  szLBOutput[50];

 BOOL FAR PASCAL DialogBoxProc (hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   HWND hCtl;
   LONG lListBoxSel;
   int  i;
   char  buffer[15];

   switch (message)
   {
   case WM_INITDIALOG:
     lpprocSubClassProc = MakeProcInstance ( (FARPROC) SubClassProc, hInst);

     lpprocListBox = (FARPROC) SetWindowLong (GetDlgItem (hDlg, IDLISTBOX),
         GWL_WNDPROC,
         (long)lpprocSubClassProc);

     hCtl = GetDlgItem (hDlg, IDLISTBOX);
     i =  ID_FEET;
     while (LoadString (hInst, i, (LPSTR)buffer, MAXSTRLEN) != 0)
     {
       SendMessage (hCtl, LB_ADDSTRING, 0, (LONG) (LPSTR)buffer);
       i++;
     }

     SetFocus (hCtl);
     return (TRUE);

   case WM_COMMAND:
     switch (wParam)
     {
     case IDLISTBOX:
       if ( (HIWORD (lParam)) == 2)
       {
   hCtl = GetDlgItem (hDlg, IDLISTBOX);

   lListBoxSel = SendMessage (hCtl, LB_GETCURSEL, 0,
       (LONG) (LPSTR)"");
   SendMessage (hCtl, LB_GETTEXT, (WORD) lListBoxSel,
       (LONG) (LPSTR)szLBOutput);
   MessageBox (NULL, (LPSTR)szLBOutput, (LPSTR)"Chose from listbox:",
       MB_OK);
   return (TRUE);
       }
       else
   return (FALSE);
       break;

     case IDOK:
       hCtl = GetDlgItem (hDlg, IDLISTBOX);
       lListBoxSel = SendMessage (hCtl, LB_GETCURSEL, 0, (LONG) (LPSTR)"");
       if (lListBoxSel == -1L)
   i = 1;
       else
   SendMessage (hCtl, LB_GETTEXT, (WORD)lListBoxSel,
       (LONG) (LPSTR)szLBOutput);
       EndDialog (hDlg, TRUE);
       return (TRUE);

     case IDCANCEL:
       EndDialog (hDlg, TRUE);
       return (TRUE);

     default:
       return (FALSE);
     }
     break;

   default:
     return (FALSE);
     break;
   }
 }


 long  FAR PASCAL SubClassProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
 {
   CallWindowProc (lpprocListBox, hWnd, message, wParam, lParam);
 /*  Pass Info onto the default control procedure  */
   return 0L;
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)"fonttest";
   pHelloClass->lpszClassName  = (LPSTR)"CallWindowProc";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;

   HelloInit (hInstance);
   hWnd = CreateWindow ( (LPSTR)"CallWindowProc",
       (LPSTR)"CallWindowProc ()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL);      /* no params to pass on */

   hInst = hInstance;

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
   }
   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_COMMAND:
     lpprocDlgProc = MakeProcInstance ( (FARPROC)DialogBoxProc, hInst);
     DialogBox (hInst, MAKEINTRESOURCE (5), hWnd, lpprocDlgProc);
     FreeProcInstance ( (FARPROC)lpprocDlgProc);
     break;

   case WM_DESTROY:
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, message, wParam, lParam);
     break;
   }
   return (0L);
 }




 DDEAPP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DDE\DDEAPP\DDEAPP.C

 /*
  *      ddeapp.c
  *
  *      This is a dummy application used to test the DDE capabilities
  *      of Microsoft Excel.
  *
  */

 #include <windows.h>
 #include "ddeapp.h"

 #define GMEM_DDESHARE 0x2000
 #define EXCEL

 #ifdef EXCEL
 #define szAppDef "Excel"
 #define szDocDef "Sheet1"
 #define szRefDef "r1c1:c1c2"
 #define szDataDef "42"
 #endif

 #ifdef OPUS
 #define szAppDef "Opus"
 #define szDocDef "opus.doc"
 #define szRefDef "bkmk1"
 #define szDataDef "Foo bar."
 #endif

 #ifdef FISH
 #define szAppDef "Fish"
 #define szDocDef "sub"
 #define szRefDef "bkmk1"
 #define szDataDef "[l]"
 #endif

 #ifndef FISH
 #ifndef OPUS
 #ifndef EXCEL
 #define szAppDef ""
 #define szDocDef ""
 #define szRefDef ""
 #define szDataDef ""
 #endif
 #endif
 #endif


 long far pascal DdeWndProc(HWND, unsigned, int, long);
 BOOL far pascal InitiateDlg(HWND, unsigned, int, long);
 BOOL far pascal ExecuteDlg(HWND, unsigned, int, long);
 BOOL far pascal PokeDlg(HWND, unsigned, int, long);
 BOOL far pascal TermDlg(HWND, unsigned, int, long);
 BOOL far pascal RequestDlg(HWND, unsigned, int, long);
 BOOL far pascal UnadviseDlg(HWND, unsigned, int, long);

 void PostClientMsg(int, int, ATOM, int);
 void ChnlBox(HWND, int);
 void ClipFmtBox(HWND,int);

 BOOL FInit(int);
 BOOL FGetAck(HWND);
 int  IclListBox(HWND,int);


 HANDLE  hinstDDE;
 HWND    hwndDDE;
 HBRUSH  hbrBack;
 HCURSOR hcrsWait;
 HCURSOR hcrsArrow;

 /* supported clipboard formats */
 #define szClipRTF   "Rich Text Format"
 #define szClipLink  "Link"
 #define szClipCSV   "Csv"
 #define szClipBitPrinter  "Printer_Bitmap"
 #define szClipMetaPrinter "Printer_Picture"

 #define icfMax 9
 #define icfRTF 5
 #define icfCSV 6
 #define icfBitPrinter 7
 #define icfMetaPrinter 8
 int rgcf[icfMax] = {
         CF_TEXT,
         CF_SYLK,
         CF_DIF,
         CF_BITMAP,
         CF_METAFILEPICT
 };

 int  cfLink;
 int  iRadioButton, iRadioButtonTemp;
 int  iResult, iAck;
 BOOL fInInitiate = FALSE;
 HWND hwndLink;

 char szApp[256]  = szAppDef;
 char szDoc[256]  = szDocDef;
 char szRef[256]  = szRefDef;
 char szData[245] = szDataDef;

 int cfCur;
 int iclCur;

 PLCL **hplcl;           /* channel array */
 PLDL **hpldl;           /* dependent link array */


 /*      WinMain
  *
  *      Main entry point for DDE dummy application.
  *
  *      Arguments:
  *              hinst
  *              hinstPrev
  *              lpszCmdLine
  *              sw
  *
  *      Returns:
  *
  */
 int far pascal WinMain(hinst, hinstPrev, lpszCmdLine, sw)
 HANDLE hinst;
 HANDLE hinstPrev;
 char far *lpszCmdLine;
 int sw;
 {
    MSG msg;
    PL **HplInit();

    hinstDDE = hinst;

    if (!FInit(sw))
            return(0);

    hplcl = (PLCL **)HplInit(sizeof(CL));
    hpldl = (PLDL **)HplInit(sizeof(DL));

    rgcf[icfRTF] = RegisterClipboardFormat((LPSTR)szClipRTF);
    cfLink       = RegisterClipboardFormat((LPSTR)szClipLink);
    rgcf[icfCSV] = RegisterClipboardFormat((LPSTR)szClipCSV);
    rgcf[icfBitPrinter] = RegisterClipboardFormat((LPSTR)szClipBitPrinter);
    rgcf[icfMetaPrinter] = RegisterClipboardFormat((LPSTR)szClipMetaPrinter);
    while (GetMessage((MSG far *)&msg, NULL, 0, 0)) {
            TranslateMessage((MSG far *)&msg);
            DispatchMessage((MSG far *)&msg);
    }

    return(msg.wParam);
 }


 /* ----------------------------------------------------- */
 void Error(sz)
 char *sz;
 {
    MessageBeep(MB_OK|MB_ICONHAND|MB_APPLMODAL);
    MessageBox(hwndDDE, (LPSTR)sz, (LPSTR)"DDE failure", MB_OK|MB_ICONHAND|MB_
 }


 /* -----------------------------------------------------
  *      CchSzLen
  *
  *      Returns the length of a null-terminated string.
  *
  *      Arguments:
  *              sz
  *
  *      Returns:
  *              length of the string
  */
 int CchSzLen(sz)
 char far *sz;
 {
    int cch;

    cch = 0;
    while (*sz++)
            cch++;
    return(cch);
 }


 /* ----------------------------------------------------
  *      bltbx
  *
  *      Far block transfer.
  *
  *      Arguments:
  *              lpbFrom         source buffer
  *              lpbTo           destination buffer
  *              cb              number of bytes to move
  *
  *      Returns:
  *              nothing.
  *
  *      Warning:
  *              does not handle over-lapping transfer!
  */
 void bltbx(lpbFrom, lpbTo, cb)
 BYTE far *lpbFrom;
 BYTE far *lpbTo;
 unsigned cb;
 {
         while (cb--)
                 *lpbTo++ = *lpbFrom++;
 }


 /* -----------------------------------------------------
  *      FInit
  *
  *      Initializes the window app.
  *
  *      Arguments:
  *              sw              type of ShowWindow call to make on
  *                              first window created.
  *
  *      Returns:
  *              TRUE if successful
  */
 BOOL FInit(sw)
 int sw;
 {
    WNDCLASS cls;
    HDC hdc;
    int dxScreen, dyScreen;

 /* register window class */

    hbrBack   = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
    hcrsArrow = LoadCursor(NULL, IDC_ARROW);
    hcrsWait  = LoadCursor(NULL, IDC_WAIT);

    cls.lpszClassName = (LPSTR)"DdeApp";
    cls.lpfnWndProc   = DdeWndProc;
    cls.hInstance     = hinstDDE;
    cls.hIcon         = LoadIcon(NULL, IDI_HAND);
    cls.hCursor       = NULL;
    cls.lpszMenuName  = MAKEINTRESOURCE(mbDde);
    cls.hbrBackground = hbrBack;
    cls.style         = 0;
    cls.cbClsExtra    = cls.cbWndExtra = 0;
    if (!RegisterClass((WNDCLASS far *)&cls))
            return(FALSE);

 /* create initial tiled window */

    hdc = CreateDC((LPSTR)"DISPLAY", NULL, NULL, NULL);
    dxScreen = GetDeviceCaps(hdc, HORZRES);
    dyScreen = GetDeviceCaps(hdc, VERTRES);
    DeleteDC(hdc);
    hwndDDE = CreateWindow((LPSTR)"DdeApp",
                    (LPSTR)"Acme DDE Application",
                    WS_OVERLAPPEDWINDOW,
                    0, 0, dxScreen/2, dyScreen/4,
                    NULL, NULL, hinstDDE, NULL);
    ShowWindow(hwndDDE, sw);

    return(TRUE);
 }


 /* ----------------------------------------------------- */

 BOOL far pascal InitiateDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
     switch (wm) {
     case WM_INITDIALOG:
             SetDlgItemText(hdlg, idtxtApp, (LPSTR)szApp);
             SetDlgItemText(hdlg, idtxtDoc, (LPSTR)szDoc);
             break;
     case WM_COMMAND:
             switch (wParam) {
             case IDOK:
                     GetDlgItemText(hdlg, idtxtApp, (LPSTR)szApp, sizeof(szApp
                     GetDlgItemText(hdlg, idtxtDoc, (LPSTR)szDoc, sizeof(szDoc
                     EndDialog(hdlg, TRUE);
                     break;
             case IDCANCEL:
                     EndDialog(hdlg, FALSE);
                     break;
             }
     default:
             return(FALSE);
     }
     return(TRUE);
 }

 /* ----------------------------------------------------- */

 BOOL far pascal RequestDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
    HWND hctl;
    int icf;

    switch (wm) {
    case WM_INITDIALOG:
            ChnlBox(hdlg, idlboxChnl);
            ClipFmtBox(hdlg, idlboxFmt);
            SetDlgItemText(hdlg, idtxtRef, (LPSTR)szRef);
            SendDlgItemMessage(hdlg, idlboxChnl, LB_SETCURSEL, 0, 0L);
            return(TRUE);
    case WM_COMMAND:
            switch (wParam) {
            case IDOK:
                    if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1)
                            return(TRUE);
                    if ((icf = SendMessage(GetDlgItem(hdlg, idlboxFmt),
                                    LB_GETCURSEL, 0, 0L)) == -1)
                            return(TRUE);
                    GetDlgItemText(hdlg, idtxtRef, (LPSTR)szRef, sizeof(szRef)
                    cfCur = rgcf[icf];
                    EndDialog(hdlg, TRUE);
                    return(TRUE);
            case IDCANCEL:
                    EndDialog(hdlg, FALSE);
                    return(TRUE);
            default:
                    return(FALSE);
            }
    default:
            return(FALSE);
    }
    return(TRUE);
 }


 /* ----------------------------------------------------- */
 void LinkBox(hdlg, idlbox, icl)
 HWND hdlg;
 int idlbox;
 int icl;
 {
     int idl;
     PLDL *ppldl;
     HWND hctl;
     char sz[256];

     hctl = GetDlgItem(hdlg, idlbox);
     SendMessage(hctl, LB_RESETCONTENT, 0, 0L);
     ppldl = (PLDL *)LocalLock((HANDLE)hpldl);
     for (idl = 0; idl < ppldl->idlMax; idl++) {
         if (!ppldl->rgdl[idl].fUsed || ppldl->rgdl[idl].icl != icl)
                 continue;
         GlobalGetAtomName(ppldl->rgdl[idl].atomRef, (LPSTR)sz, sizeof(sz));
         SendMessage(hctl, LB_ADDSTRING, 0, (DWORD)(LPSTR)sz);
         SendMessage(hctl, LB_GETCOUNT, 0, 0L);
     }
     LocalUnlock((HANDLE)hpldl);
 }


 /* ----------------------------------------------------- */

 BOOL far pascal UnadviseDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
     HWND hctl;
     int il;

     switch (wm) {
     case WM_INITDIALOG:
             ChnlBox(hdlg, idlboxChnl);
             SendDlgItemMessage(hdlg, idlboxChnl, LB_SETCURSEL, 0, 0L);
             return(TRUE);
     case WM_COMMAND:
             switch (wParam) {
             case IDOK:
                     if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1)
                             return(TRUE);
                     if ((il = SendMessage(hctl = GetDlgItem(hdlg, idlboxRef),
                                     LB_GETCURSEL, 0, 0L)) == -1)
                             return(TRUE);
                     SendMessage(hctl, LB_GETTEXT, il, (DWORD)(LPSTR)szRef);
                     EndDialog(hdlg, TRUE);
                     return(TRUE);
             case IDCANCEL:
                     EndDialog(hdlg, FALSE);
                     return(TRUE);
             case idlboxChnl:
                     if (HIWORD(lParam) == LBN_SELCHANGE) {
                             if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1
                                     return(TRUE);
                             LinkBox(hdlg, idlboxRef, iclCur);
                             return(TRUE);
                     }
                     return(FALSE);
             default:
                     return(FALSE);
             }
         default:
             return(FALSE);
     }
     return(TRUE);
 }


 /* ----------------------------------------------------- */

 BOOL far pascal ExecuteDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
    switch (wm) {
    case WM_INITDIALOG:
            ChnlBox(hdlg, idlboxChnl);
            SetDlgItemText(hdlg, idtxtRef, (LPSTR)szRef);
            SendDlgItemMessage(hdlg, idlboxChnl, LB_SETCURSEL, 0, 0L);
            break;
    case WM_COMMAND:
            switch (wParam) {
            case IDOK:
                    GetDlgItemText(hdlg, idtxtRef, (LPSTR)szRef, sizeof(szRef)
                    if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1)
                            return(TRUE);
                    EndDialog(hdlg, TRUE);
                    return(TRUE);
            case IDCANCEL:
                    EndDialog(hdlg, FALSE);
                    return(TRUE);
            }
    default:
            return(FALSE);
    }
    return(TRUE);
 }

 /* ----------------------------------------------------- */

 BOOL far pascal PokeDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
    switch (wm) {
    case WM_INITDIALOG:
            ChnlBox(hdlg, idlboxChnl);
            SetDlgItemText(hdlg, idtxtRef, (LPSTR)szRef);

            CheckRadioButton(hdlg, idradioText, idradioFile, idradioText);
            iRadioButtonTemp = idradioText;

            /* file is not implemented so it is disabled */
            EnableWindow( GetDlgItem(hdlg,idradioFile), FALSE );

            SendDlgItemMessage(hdlg, idlboxChnl, LB_SETCURSEL, 0, 0L);

            break;

    case WM_COMMAND:
            switch (wParam) {
            case IDOK:

                   iResult = GetDlgItemText(hdlg, idtxtData,
                                            (LPSTR)szData, sizeof(szData));
                   iResult = GetDlgItemText(hdlg, idtxtRef,
                                            (LPSTR)szRef, sizeof(szRef));
                   if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1)
                      return(TRUE);

                   iRadioButton = iRadioButtonTemp;

                   /* verify contents of Poke message */
                   /* if the button is csv
                         and the ref is < 5 characters
                         then if the data has a comma in it
                                 then display a warning message
                    */

                   if ( iRadioButtonTemp == idradioCsv && iResult<5 ) {
                      /* check for comma in data */
                      MessageBox( GetFocus(), "Ref may be too small",
                                              "Warning", MB_OK);

                      }

                    EndDialog(hdlg, TRUE);
                    return(TRUE);
            case IDCANCEL:
                    EndDialog(hdlg, FALSE);
                    return(TRUE);

            case idradioText:
            case idradioCsv:
            case idradioFile:
                    CheckRadioButton(hdlg, idradioText, idradioFile,
                       (iRadioButtonTemp = wParam));
                    return(TRUE);
                    break;

            }
    default:
            return(FALSE);
    }
    return(TRUE);
 }





 /* ----------------------------------------------------- */

 BOOL far pascal TermDlg(hdlg, wm, wParam, lParam)
 HWND hdlg;
 unsigned wm;
 int wParam;
 long lParam;
 {
    switch (wm) {
    case WM_INITDIALOG:
            ChnlBox(hdlg, idlboxChnl);
            SendDlgItemMessage(hdlg, idlboxChnl, LB_SETCURSEL, 0, 0L);
            break;
    case WM_COMMAND:
            switch (wParam) {
            case IDOK:
                    if ((iclCur = IclListBox(hdlg, idlboxChnl)) == -1)
                            return(TRUE);
                    EndDialog(hdlg, TRUE);
                    break;
            case IDCANCEL:
                    EndDialog(hdlg, FALSE);
                    break;
            default:
                    break;
            }
    default:
            return(FALSE);
    }
    return(TRUE);
 }


 /* -----------------------------------------------------
  *      RemoveLinks
  *
  *      Removes all a channel's links from our data structures.
  *
  *      Arguments:
  *              icl             channel to remove links from
  *
  *      Returns:
  *              nothing.
  */
 void RemoveLinks(icl)
 int icl;
 {
     int idl;
     PLDL *ppldl;

     ppldl = (PLDL *)LocalLock((HANDLE)hpldl);
     for (idl = 0; idl < ppldl->idlMax; idl++) {
             if (ppldl->rgdl[idl].fUsed && ppldl->rgdl[idl].icl == icl)
                     ppldl->rgdl[idl].fUsed = FALSE;
     }
     LocalUnlock((HANDLE)hpldl);
 }



 /* -----------------------------------------------------
  *      AddPl
  *
  *      Adds an item to a PL
  *
  *      Arguments:
  *              hpl
  *              pbData
  *
  *      Returns:
  *              Nothing.
  */
 void AddPl(hpl, pbData)
 PL **hpl;
 BYTE *pbData;
 {
    PL *ppl;
    BYTE *pb;
    int cbItem;
    int i, iMax;
    int dAlloc;

    ppl = (PL *)LocalLock((HANDLE)hpl);
    cbItem = ppl->cbItem;
    iMax = ppl->iMax;
    for (i = 0, pb = ppl->rg; i < iMax; i++, pb += cbItem) {
            if (!*(int *)pb)
                    goto Return;
    }
    dAlloc = ppl->dAlloc;
    LocalUnlock((HANDLE)hpl);
    LocalReAlloc((HANDLE)hpl, sizeof(PL)-1 + (iMax + dAlloc) * cbItem,
                    LMEM_MOVEABLE|LMEM_ZEROINIT);
    ppl = (PL *)LocalLock((HANDLE)hpl);
    ppl->iMax = iMax + dAlloc;
    pb = &ppl->rg[cbItem * iMax];
 Return:
    bltbx((BYTE far *)pbData, (BYTE far *)pb, cbItem);
    *(int *)pb = TRUE;
    LocalUnlock((HANDLE)hpl);
 }



 /* -----------------------------------------------------
  *      HplInit
  *
  *      Initializes a plex
  *
  *      Arguments:
  *              cbItem          sizeof item to put in plex
  *
  *      Returns:
  *              handle to new plex
  */
 PL **HplInit(cbItem)
 int cbItem;
 {
    PL **hpl, *ppl;

    hpl = (PL **)LocalAlloc(LMEM_MOVEABLE|LMEM_ZEROINIT, sizeof(PL)-1);
    ppl = (PL *)LocalLock((HANDLE)hpl);
    ppl->iMax = 0;
    ppl->dAlloc = 5;
    ppl->cbItem = cbItem;
    LocalUnlock((HANDLE)hpl);
    return(hpl);
 }


 /* -------------------------------------------------
  *      RemovePl
  *
  *      Removes an item from a plex
  *
  *      Arguments:
  *              hpl
  *              i
  *
  *      Returns:
  *              nothing.
  */
 void RemovePl(hpl, i)
 PL **hpl;
 int i;
 {
    PL *ppl;

    ppl = (PL *)LocalLock((HANDLE)hpl);
    *(int *)&ppl->rg[i * ppl->cbItem] = FALSE;
    LocalUnlock((HANDLE)hpl);
 }


 /* ----------------------------------------------------
  *      GetPl
  *
  *      gets an item from a plex
  *
  *      Arguments:
  *              hpl
  *              i
  *              pb
  *
  *      Returns:
  *              nothing.
  */
 void GetPl(hpl, i, pb)
 PL **hpl;
 int i;
 BYTE *pb;
 {
     PL *ppl;

     ppl = (PL *)LocalLock((HANDLE)hpl);
     bltbx((BYTE far *)&ppl->rg[i * ppl->cbItem], (BYTE far *)pb, ppl->cbItem)
     LocalUnlock((HANDLE)hpl);
 }


 /* -----------------------------------------------------
  *      SendInitiate
  *
  *      Broadcasts WM_DDE_INITIATE message for the given reference string
  *
  *      Arguments:
  *              szApp
  *              szDoc
  *
  *      Returns:
  *              Nothing
  */
 void SendInitiate(szApp, szDoc)
 char *szApp;
 char *szDoc;
 {
     ATOM atomApp, atomDoc;

     atomApp = *szApp == 0 ? NULL : GlobalAddAtom((LPSTR)szApp);
     atomDoc = *szDoc == 0 ? NULL : GlobalAddAtom((LPSTR)szDoc);
     iAck = FALSE;        /* no conversation is active */
     fInInitiate = TRUE;
     SendMessage((HWND)-1, WM_DDE_INITIATE, hwndDDE, MAKELONG(atomApp, atomDoc
     fInInitiate = FALSE;
     if (atomApp != NULL)
             GlobalDeleteAtom(atomApp);
     if (atomDoc != NULL)
             GlobalDeleteAtom(atomDoc);
     if (!iAck)
       MessageBox( GetFocus(), "Nobody wants to talk.", "Warning", MB_OK);

 }


 /* -----------------------------------------------------
  *      SendTerminate
  *
  *      Arguments:
  *              icl
  *
  *      Returns:
  *              Nothing.
  */
 void SendTerminate(icl)
 int icl;
 {
 #ifdef BOGUS
     PostClientMsg(icl, WM_DDE_UNADVISE, 0, 0);
     if (!FGetAck(icl)) {
             Error("Terminate aborted:  Unadvise failed");
             return;
     }
 #endif
     PostClientMsg(icl, WM_DDE_TERMINATE, 0, 0);
     RemoveLinks(icl);
     RemovePl(hplcl, icl);
 }


 /* -----------------------------------------------------
  *      SendRequest
  *
  *      Sends a WM_DDE_REQUEST message
  *
  *      Arguments:
  *              icl
  *              cf
  *              szRef
  *
  *      Returns:
  *              Nothing.
  */
 void SendRequest(icl, cf, szRef)
 int icl;
 int cf;
 char *szRef;
 {
    ATOM atom;

    atom = GlobalAddAtom((LPSTR)szRef);
    PostClientMsg(icl, WM_DDE_REQUEST, atom, cf);
 }


 /* -----------------------------------------------------
  *      SendAdvise
  *
  *      Sends WM_DDE_ADVISE message to establish hot link
  *
  *      Arguments:
  *              icl
  *              cf
  *              szRef
  *
  *      Returns:
  *              Nothing.
  */
 void SendAdvise(icl, cf, szRef)
 int icl;
 int cf;
 char *szRef;
 {
    ATOM atom;
    HANDLE hDdeln;
    DDELN far *lpddeln;
    BOOL fSuccess;
    DL dl;

    atom = GlobalAddAtom((LPSTR)szRef);
    hDdeln = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (DWORD)sizeof(DDELN));
    lpddeln = (DDELN far *)GlobalLock(hDdeln);
    lpddeln->cf = cf;
    lpddeln->fAckReq = FALSE;
    lpddeln->fDeferUpd = FALSE;
    GlobalUnlock(hDdeln);
    PostClientMsg(icl, WM_DDE_ADVISE, atom, hDdeln);
    if (!FGetAck(icl)) {
       Error("Advise Failed");
       GlobalFree(hDdeln);
       /* return; */
    }
    else {
      dl.icl = icl;
      dl.atomRef = atom;
      AddPl(hpldl, &dl);
    }
 }


 /* -----------------------------------------------------
  *      SendUnadvise
  *
  *      Breaks a link by sending an WM_DDE_UNADVISE.
  *
  *      Arguments:
  *              icl
  *              szRef
  *
  *      Returns:
  *              Nothing.
  */
 void SendUnadvise(icl, szRef)
 int icl;
 char *szRef;
 {
    ATOM atom;
    PLDL *ppldl;
    int idl;

    if (*szRef == 0) {
       PostClientMsg(icl, WM_DDE_UNADVISE, NULL, NULL);
       if (!FGetAck(icl)) {
          Error("Unadvise Failed");
          return;
       }
       RemoveLinks(icl);
       return;
    }
    atom = GlobalAddAtom((LPSTR)szRef);
    ppldl = (PLDL *)LocalLock((HANDLE)hpldl);
    for (idl = 0; idl < ppldl->idlMax; idl++) {
       if (ppldl->rgdl[idl].fUsed &&
           ppldl->rgdl[idl].atomRef == atom &&
           ppldl->rgdl[idl].icl == icl) {
          PostClientMsg(icl, WM_DDE_UNADVISE, atom, NULL);
          if (!FGetAck(icl)) {
             Error("Unadvise Failed");
             break;
          }
          GlobalDeleteAtom(atom);
          RemovePl(hpldl, idl);
          break;
       }
    }
    LocalUnlock((HANDLE)hpldl);
 }


 /* -----------------------------------------------------
  *      SendExecute
  *
  *      Sends a WM_DDE_EXECUTE.
  *
  *      Arguments:
  *              icl
  *              szExec
  *
  *      Returns:
  *              Nothing.
  */
 void SendExecute(icl, szExec)
 int icl;
 char *szExec;
 {
    int cch;
    char far *lpsz;
    HANDLE hDde;

    cch  = CchSzLen((char far *)szExec);
    hDde = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (DWORD)cch+1);
    lpsz = (char far *)GlobalLock(hDde);
    bltbx((char far *)szExec, lpsz, cch+1);
    GlobalUnlock(hDde);
    PostClientMsg(icl, WM_DDE_EXECUTE, hDde, NULL);
    if (!FGetAck(icl))
            Error("Execute Failed");
    GlobalFree(hDde);
 }

 /* -----------------------------------------------------
  *      SendPoke
  *
  *      Sends a WM_DDE_POKE
  *
  *      Arguments:
  *              icl
  *              szRef
  *              szPoke
  *
  *      Returns:
  *              Nothing.
  */
 void SendPoke(icl, szRef, szPoke)
 int icl;
 char *szRef;
 char *szPoke;
 {
    int cch;
    DDEUP far *lpddeup;
    ATOM atom;
    HANDLE hDdeup;

    switch(iRadioButton) {

      case idradioText:
           MessageBox( GetFocus(), "Text", "Sending", MB_OK);
           break;

      case idradioCsv:
           MessageBox( GetFocus(), "Csv" , "Sending", MB_OK);
           break;

      case idradioFile:
           MessageBox( GetFocus(), "File" , "Sending", MB_OK);
           break;

      default:
           MessageBox( GetFocus(), "Unknown" , NULL, MB_OK);
           break;
    }

    atom   = GlobalAddAtom((LPSTR)szRef);
    cch    = CchSzLen((char far *)szPoke);
    hDdeup = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (DWORD)sizeof(DDEUP)+c
    lpddeup            = (DDEUP far *)GlobalLock(hDdeup);
    lpddeup->cf        = (iRadioButton == idradioText) ? CF_TEXT : rgcf[icfCSV
    lpddeup->fAckReq   = FALSE;
    lpddeup->fRelease  = TRUE;
    bltbx((char far *)szPoke, lpddeup->rgb, cch+1);
    GlobalUnlock(hDdeup);
    PostClientMsg(icl, WM_DDE_POKE, atom, hDdeup);
    if (!FGetAck(icl))
            Error("Poke Failed");
 }

 /* -----------------------------------------------------
  *      BenchPoke
  *
  *      Sends a whole bunch of WM_DDE_POKEs
  *
  *      Arguments:
  *              icl
  *              szRef
  *              szPoke
  *
  *      Returns:
  *              Nothing.
  */
 void BenchPoke(icl, szRef, szPoke)
 int icl;
 char *szRef;
 char *szPoke;
 {
   int i;
   int cch;
   DDEUP far *lpddeup;
   ATOM atom;
   HANDLE hDdeup;

   Error("Start");
   for (i=0; i<10000; i++)
           {
           PostClientMsg(icl, WM_DDE_TEST, NULL, NULL);
           if (!FGetAck(icl))
                   Error("No Ack Received");
           }
   Error("Stop");
 }


 /* ----------------------------------------------------- */
 int Waste(hwnd, wm, wParam, lParam)
 HWND hwnd;
 int wm;
 int wParam;
 long lParam;
 {
         return(TRUE);
 }


 /* ----------------------------------------------------- */
 void BenchCall()
 {
   long l;

   Error("Start");
   for (l=0; l<1000000; l++)
           if (!Waste(1234, WM_DDE_TEST, 5678, 0L))
                   Error("No Ack Received");
   Error("Stop");
 }


 /* -----------------------------------------------------
  *      FGetAck
  *
  *      Waits for an ACK message to be returned
  *
  *      Arguments:
  *              icl             channel to receive ACK from
  *
  *      Returns:
  *              TRUE if affirmative ACK received within a fairly long
  *              time period
  *
  *      Note:
  *              This method is not recommended for large applications.
  */
 BOOL FGetAck(icl)
 HWND icl;
 {
     MSG msg;
     int tid;
     HWND hwndInt, hwndExt;
     BOOL fAck;
  msAckWait 60000 /* one minute */

     hwndExt = (*hplcl)->rgcl[icl].hwndExt;
     hwndInt = (*hplcl)->rgcl[icl].hwndInt;
 #ifdef TIMER
     tid = SetTimer(NULL, 0, msAckWait, NULL);
 #endif
     fAck = FALSE;
     for (;;) {
        GetMessage((MSG far *)&msg, NULL, 0, 0);
        if (msg.message == WM_DDE_ACK && msg.wParam == hwndExt)
           {
           if (LOWORD(msg.lParam) & 0x8000)
                   fAck = TRUE;
           if (HIWORD(msg.lParam)>= 0xc000)
                   GlobalDeleteAtom(HIWORD(msg.lParam));
           break;
           }
        TranslateMessage((MSG far *)&msg);
        DispatchMessage((MSG far *)&msg);
 #ifdef TIMER
        if (PeekMessage((MSG far *)&msg, NULL,
                            WM_TIMER, WM_TIMER, PM_REMOVE) &&
                        msg.wParam == tid)
                break;
 #endif
        WaitMessage();
     }
 #ifdef TIMER
     KillTimer(NULL, tid);
 #endif
     return(fAck);
 }




 /* -----------------------------------------------------
  * P A S T E  L I N K
  *
  *  Get the paste link string from the clipboard and display it.
  *
 */

 void PasteLink ()
 {
    int  isp;
    char far *lpch;
    char far *lpchT;
    RECT rect;
    HDC  hdc;
    HANDLE hClipboard;

    if (!OpenClipboard(hwndDDE))
        {
        Error("Cannot open clipboard");
        return;
        }

    if ((hClipboard = GetClipboardData(cfLink)) == NULL)
        {
        Error("Cannot render clipboard in Link format");
        }
    else
        {
        hdc = GetDC(hwndDDE);
        lpch = GlobalLock(hClipboard);
        GetClientRect(hwndDDE, (LPRECT)&rect);
        hbrBack = SelectObject(hdc, hbrBack);
        PatBlt(hdc, rect.left, rect.top, rect.right - rect.left,
                 rect.bottom - rect.top, PATCOPY);
        SelectObject(hdc, hbrBack);
        for (isp=0, lpchT = lpch; isp < 2; lpchT++)
                if (!*lpchT)
                        {
                        *lpchT = ' ';
                        isp++;
                        }
        DrawText(hdc, lpch, CchSzLen(lpch), (LPRECT)&rect,
                DT_LEFT|DT_EXPANDTABS);
        ReleaseDC(hwndDDE, hdc);
        GlobalUnlock(hClipboard);
        }

    CloseClipboard();
 }


 /* -----------------------------------------------------
  *      DoDialog
  *
  *      Brings up a dialog.
  *
  *      Arguments:
  *              idd             dialog index to bring up
  *              lpfn            dialog proc to use
  *
  *      Returns:
  *              Dialog return code
  */
 int FDoDialog(idd, lpfn)
 int idd;
 FARPROC lpfn;
 {
    int w;

    lpfn = MakeProcInstance(lpfn, hinstDDE);
    w = DialogBox(hinstDDE, MAKEINTRESOURCE(idd), hwndDDE, lpfn);
    FreeProcInstance(lpfn);
    return(w);
 }


 /* ----------------------------------------------------
  *      ClipFmtBox
  *
  *      Initializes clipboard format dialog list box.
  *
  *      Arguments:
  *              hdlg
  *              idlbox
  *
  *      Returns:
  *              nothing.
  */
 void ClipFmtBox(hdlg, idlbox)
 HWND hdlg;
 int idlbox;
 {
     HWND hctl;
     int icf;
     int cf;
     char sz[256];

     hctl = GetDlgItem(hdlg, idlbox);
     for (icf = 0; icf < icfMax; icf++) {
         switch (cf = rgcf[icf]) {
         case CF_TEXT:
                 bltbx((LPSTR)"CF_TEXT", (LPSTR)sz, 8);
                 break;
         case CF_BITMAP:
                 bltbx((LPSTR)"CF_BITMAP", (LPSTR)sz, 10);
                 break;
         case CF_METAFILEPICT:
                 bltbx((LPSTR)"CF_METAFILEPICT", (LPSTR)sz, 12);
                 break;
         case CF_SYLK:
                 bltbx((LPSTR)"CF_SYLK", (LPSTR)sz, 8);
                 break;
         case CF_DIF:
                 bltbx((LPSTR)"CF_DIF", (LPSTR)sz, 7);
                 break;
         default:
                 sz[GetClipboardFormatName(cf, (LPSTR)sz, sizeof(sz))] = 0;
                 break;
         }
         SendMessage(hctl, LB_ADDSTRING, 0, (DWORD)(LPSTR)sz);
     }
 }


 /* ----------------------------------------------------
  *      ChnlBox
  *
  *      Initializes channel dialog list box.
  *
  *      Arguments:
  *              hdlg
  *              idlbox
  *
  *      Returns:
  *              nothing.
  */
 void ChnlBox(hdlg, idlbox)
 HWND hdlg;
 int idlbox;
 {
     HWND hctl;
     PLCL *pplcl;
     int icl;
     HWND hwndExt;
     char sz[256];

     hctl = GetDlgItem(hdlg, idlbox);
     pplcl = (PLCL *)LocalLock((HANDLE)hplcl);
     for (icl = 0; icl < pplcl->iclMax; icl++) {
         if (!pplcl->rgcl[icl].fUsed)
                 continue;
         hwndExt = pplcl->rgcl[icl].hwndExt;
         GetWindowText(hwndExt, (LPSTR)sz, sizeof(sz));
         SendMessage(hctl, LB_ADDSTRING, 0, (DWORD)(LPSTR)sz);
     }
     LocalUnlock((HANDLE)hplcl);
 }


 /* ----------------------------------------------------
  *      IclListBox
  *
  *      Given a listbox, returns the icl for the channel selected in that
  *      listobx.
  *
  *      Arguments:
  *              hdlg            dialog handle
  *              idlbox          listbox item index.
  *
  *      Returns:
  *              channel index
  */
 int IclListBox(hdlg, idlbox)
 HWND hdlg;
 int idlbox;
 {
     int il, icl;
     PLCL *pplcl;

     if ((il = SendMessage(GetDlgItem(hdlg, idlbox), LB_GETCURSEL, 0, 0L)) ==
             return(-1);
     pplcl = (PLCL *)LocalLock((HANDLE)hplcl);
     for (icl = 0; icl < pplcl->iclMax; icl++) {
             if (pplcl->rgcl[icl].fUsed && il-- == 0)
                     goto Return;
     }
     icl = -1;
 Return:
     LocalUnlock((HANDLE)hplcl);
     return(icl);
 }

 /* ---------------------------------------------------- */

 void PostClientMsg(icl, wm, atom, cf)
 int icl;
 int wm;
 ATOM atom;
 int cf;
 {
     HWND hwndExt;
     PLCL *pplcl;

     pplcl = (PLCL *)LocalLock((HANDLE)hplcl);
     hwndExt = pplcl->rgcl[icl].hwndExt;
     PostMessage(hwndExt, wm,
             (WORD)pplcl->rgcl[icl].hwndInt,
             MAKELONG(cf, atom));
     LocalUnlock((HANDLE)hplcl);
 }


 int cxScrollLast;
 int cyScrollLast;

 /* ---------------------------------------------------- */
 FShowMetaFilePict( hdc, prc, hmfp, cxScroll, cyScroll )
 HDC      hdc;
 register PRECT  prc;
 HANDLE   hmfp;
 int      cxScroll, cyScroll;
 {       /* Display a metafile picture in the passed rectangle.
            { cxScroll, cyScroll } is the origin within the picture at which
                         to start displaying.
            Set cxScrollLast, cyScrollLast if they have not been set already *
    HDC hMemDC;
    HBITMAP hbm;
    LPMETAFILEPICT lpmfp;
    METAFILEPICT mfp;
    int mmT;
    POINT pt, ptT;
    int level;
    int cxRect = prc->right - prc->left;
    int cyRect = prc->bottom - prc->top;
    int cxBitmap;
    int cyBitmap;
    int f=FALSE;

    if ((lpmfp=(LPMETAFILEPICT)GlobalLock( hmfp )) != NULL)
       {
       int mm;
       METAFILEPICT mfp;

       mfp = *lpmfp;
       GlobalUnlock( hmfp );

       if ((level = SaveDC( hdc )) != 0)
          {
          /* Compute size of picture to be displayed */

          switch (mfp.mm)
                  {
          case MM_ISOTROPIC:
                  goto NoScroll;
          case MM_ANISOTROPIC:
                  if (mfp.xExt > 0 && mfp.yExt > 0)
                          {
                          /* suggested a size */
                          mm = MM_HIMETRIC;
                          goto GetSize;
                          }
 NoScroll:
                  /* no suggested sizes, use the window size */
                  cyScrollLast = 0;   /* Not scrollable; resizes into avail. r
                  cxScrollLast = 0;
                  cxBitmap = prc->right - prc->left;
                  cyBitmap = prc->bottom - prc->top;
                  break;

          default:
                  mm = mfp.mm;
 GetSize:
                  mmT = SetMapMode(hdc, mm);
                  *((long *)&ptT) = SetWindowOrg(hdc, 0, 0);
                  pt.x = mfp.xExt;
                  pt.y = mfp.yExt;
                  LPtoDP(hdc, (LPPOINT)&pt, 1);
                  cxBitmap = pt.x;
                  cyBitmap = (mm == MM_TEXT) ? pt.y : -pt.y;
                  SetMapMode(hdc, mmT);
                  SetWindowOrg(hdc, ptT.x, ptT.y);

 CheckScroll:
                  if (cxScrollLast == -1)
                          {
                          cxScrollLast = cxBitmap - (prc->right - prc->left);
                          if ( cxScrollLast < 0)
                                  cxScrollLast = 0;
                          }
                  if (cyScrollLast == -1)
                          {
                          cyScrollLast = cyBitmap - (prc->bottom - prc->top);
                          if ( cyScrollLast < 0)
                                  cyScrollLast = 0;
                          }
                  break;
                  }

          /* We make the "viewport" to be an area the same size as the */
          /* clipboard object, and set the origin and clip region so as */
          /* to show the area we want. Note that the viewport may well be */
          /* bigger than the window. */
          IntersectClipRect( hdc, prc->left, prc->top,
                                  prc->right, prc->bottom );
          SetMapMode( hdc, mfp.mm );

          SetViewportOrg( hdc, prc->left - cxScroll, prc->top - cyScroll );
          switch (mfp.mm)
                  {
          case MM_ISOTROPIC:
                  if (mfp.xExt && mfp.yExt)
                          /* So we get the correct shape rectangle when
                          SetViewportExt gets called */
                          SetWindowExt( hdc, mfp.xExt, mfp.yExt );
                  break;

          case MM_ANISOTROPIC:
                  SetWindowExt(hdc, cxBitmap, cyBitmap);
                  SetViewportExt( hdc, cxBitmap, cyBitmap );
                  break;
                  }

          /* Since we may have scrolled, force brushes to align */
          SetBrushOrg( hdc, cxScroll - prc->left, cyScroll - prc->top );
          f = PlayMetaFile( hdc, mfp.hMF );

 NoDisplay:
          RestoreDC( hdc, level );
          }
       }

 return f;

 }

 /* ------------------------------------------------------
  *      DdeWndProc
  *
  *      Main window proc for the DDE application.
  *
  *      Arguments:
  *              hwnd            window receiving the message
  *              wm              the message
  *              wParam, lParam  additional info for the message
  *
  *      Returns:
  *              Depends on the message.
  */
 long far pascal DdeWndProc(hwnd, wm, wParam, lParam)
 HWND hwnd;
 unsigned wm;
 int wParam;
 long lParam;
 {
    int icl;
    PLCL *pplcl;
    char sz[256];
    char *pch;
    RECT rect;
    HDC hdc;
    DDEUP far *lpddeup;
    CL cl;
    HBITMAP hbmp;
    HDC hdcMem;
    BITMAP bmp;
    METAFILEPICT far *lpmfp;
    HANDLE hMF;
    BOOL fRelease;

    switch (wm) {

            case WM_DESTROY:
                    PostQuitMessage(0);
                    break;

            case WM_COMMAND:

                    switch (wParam) {

                    case idmInitiate:
                            if (FDoDialog(iddInitiate, InitiateDlg))
                                    SendInitiate(szApp, szDoc);
                            return(0L);

                    case idmTerminate:
                            if (FDoDialog(iddTerminate, TermDlg))
                                    SendTerminate(iclCur);
                            return(0L);

                    case idmRequest:
                            if (FDoDialog(iddRequest, RequestDlg))
                                    SendRequest(iclCur, cfCur, szRef);
                            return(0L);

                    case idmAdvise:
                            if (FDoDialog(iddAdvise, RequestDlg))
                                    SendAdvise(iclCur, cfCur, szRef);
                            return(0L);

                    case idmUnadvise:
                            if (FDoDialog(iddUnadvise, UnadviseDlg))
                                    SendUnadvise(iclCur, szRef);
                            return(0L);

                    case idmPoke:
                            if (FDoDialog(iddPoke, PokeDlg))
                                    SendPoke(iclCur, szRef, szData);
                            return(0L);

                    case idmExecute:
                            if (FDoDialog(iddExecute, ExecuteDlg))
                                    SendExecute(iclCur, szRef);
                            return(0L);

                    case idmBench:
                            if (FDoDialog(iddPoke, PokeDlg))
                                    BenchPoke(iclCur, szRef, szData);
                            return(0L);

                    case idmCBench:
                            BenchCall();
                            return(0L);

                    case idmPasteLink:
                            PasteLink();
                            return(0L);

                    default:
                            break;

                    }
                    break;

            case WM_DDE_TERMINATE:
                    pplcl = (PLCL *)LocalLock((HANDLE)hplcl);
                    for (icl = 0; icl < pplcl->iclMax; icl++) {
                            if (!pplcl->rgcl[icl].fUsed ||
                                pplcl->rgcl[icl].hwndExt != wParam)
                                    continue;
                            LocalUnlock((HANDLE)hplcl);
                            SendTerminate(icl);
                            return(0L);
                            }
                    LocalUnlock((HANDLE)hplcl);
                    return(0L);

            case WM_DDE_ACK:
                    if (fInInitiate) {
                            cl.hwndInt = hwnd;
                            cl.hwndExt = (HWND)wParam;
                            cl.fClient = TRUE;
                            AddPl(hplcl, &cl);
                            GlobalDeleteAtom(LOWORD(lParam));
                            iAck = TRUE;
                    } else {
                            if (LOWORD(lParam) & 0x8000)
                                    Error("Got ACK");
                            else
                                    Error("Got NACK");
                    }
                    GlobalDeleteAtom(HIWORD(lParam));
                    return(0L);

            case WM_DDE_DATA:
                    GetClientRect(hwndDDE, (LPRECT)&rect);
                    hdc = GetDC(hwndDDE);
                    hbrBack = SelectObject(hdc, hbrBack);
                    PatBlt(hdc, rect.left, rect.top,
                                    rect.right - rect.left,
                                    rect.bottom - rect.top,
                                    PATCOPY);
                    SelectObject(hdc, hbrBack);
                    lpddeup = (DDEUP far *)GlobalLock(LOWORD(lParam));
                    if (lpddeup->fAckReq)
                            PostMessage(wParam, WM_DDE_ACK,
                                    hwnd, MAKELONG(0x8000, HIWORD(lParam)));
                    else
                            GlobalDeleteAtom(HIWORD(lParam));
                    switch (lpddeup->cf)
                            {
                    default:
                            if (lpddeup->cf == rgcf[icfBitPrinter])
                                    goto GotBitmap;
                            if (lpddeup->cf == rgcf[icfMetaPrinter])
                                    goto GotMetafile;
                            if (lpddeup->cf != rgcf[icfRTF] &&
                                    lpddeup->cf != rgcf[icfCSV])
                                    break;
                            /* else fall through */
                    case CF_SYLK:
                    case CF_DIF:
                    case CF_TEXT:
                            DrawText(hdc, lpddeup->rgb,
                                            CchSzLen(lpddeup->rgb),
                                            (LPRECT)&rect,
                                            DT_LEFT|DT_EXPANDTABS);
                            break;
                    case CF_BITMAP:
 GotBitmap:
                            hdcMem = CreateCompatibleDC(hdc);
                            hbmp = *(HBITMAP far *)&lpddeup->rgb[0];
                            GetObject(hbmp, sizeof(BITMAP), (BYTE far *)&bmp);
                            hbmp = SelectObject(hdcMem, hbmp);
                            BitBlt(hdc, 0, 0, bmp.bmWidth, bmp.bmHeight,
                                            hdcMem, 0, 0, SRCCOPY);
                            hbmp = SelectObject(hdcMem, hbmp);
                            DeleteDC(hdcMem);
                            if (lpddeup->fRelease)
                                    DeleteObject(hbmp);
                            break;
                    case CF_METAFILEPICT:
 GotMetafile:
                            GetClientRect(hwndDDE, (LPRECT)&rect);
                            FShowMetaFilePict(hdc, &rect,
                                      *((HANDLE far *)&lpddeup->rgb[0]),
                                              0, 0);
                            if (lpddeup->fRelease)
                                    DeleteMetaFile(*((HANDLE far *)&lpddeup->r
                            break;
                    }
                    ReleaseDC(hwndDDE, hdc);
                    fRelease = lpddeup->fRelease;
                    GlobalUnlock(LOWORD(lParam));
                    if (fRelease)
                            GlobalFree(LOWORD(lParam));
                    return(0L);

            default:
                    break;

    }
    return(DefWindowProc(hwnd, wm, wParam, lParam));
 }




 DDESPY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DDE\DDESPY\DDESPY.C

 /*---------------------------------------------------------------------------
 |   ddespy.c      - Windows message spy application
 |
 |   Notes:
 |       "->" means "a pointer to", "->>" means "a handle to"
 |
 |   History:
 |       01/01/87 Created
 |
 \*---------------------------------------------------------------------------

 /*---------------------------------------------------------------------------
 |
 |   g e n e r a l   c o n s t a n t s
 |
 \*---------------------------------------------------------------------------

  DEBUGDX   100    /* Window sizes */
 #define DEBUGDY   100
 #define DEBUGX    50
 #define DEBUGY    50
 #define DEBUGXINC 10
 #define DEBUGYINC 30

 /*---------------------------------------------------------------------------
 |
 |   i n c l u d e   f i l e s
 |
 \*---------------------------------------------------------------------------

 #include <windows.h>
 #include <winexp.h>
 #include "ddespy.h"
 #include "dde.h"

 /*---------------------------------------------------------------------------
 |
 |   g l o b a l   v a r i a b l e s
 |
 \*---------------------------------------------------------------------------

 static  char    acAppName[]="DDE SPY";

 static  HANDLE  hInst;
 HWND    hSpyApp;
 HWND    hSpyChild;
 static  FARPROC fpxProcAbout;
 static  FARPROC fpxProcSpySet;
 static  FARPROC fpxSpyProc;
 /* static  FARPROC fpxMsgHook1;
    static  FARPROC fpxMsgHook2;
    static  FARPROC fpxOldHook1;
    static  FARPROC fpxOldHook2;
  */

 /* Global variables describing the state of the window being spyied on */
 static  BOOL    gbSpyOn  = FALSE;
 static  HWND    ghSpyWnd = NULL;
 static  BOOL    gbHook   = FALSE;
 static  FARPROC OldSpyProc;

 BOOL gbMouse = TRUE;          /* TRUE if mouse messages are to be ignored */
 BOOL gbNC    = TRUE;

 static BOOL bDisableMessages; /*  TRUE if all messages are to be ignored */


 struct TEXT_STRUCT {
     int  iFirst;                  /* First line in que */
     int  iCount;                  /* Number of lines in que */
     int  iTop;                    /* Line at top of window */
     int  iLeft;                   /* X offset of the window */
     char *Text[MAXLINES];         /* Que of Text in window */
     int  Len[MAXLINES];           /* String Length of text */
     int  MaxLen;                  /* Max String Length */
 };

 typedef struct TEXT_STRUCT *PTXT; /* pointer to a text struct */
 typedef PTXT               *HTXT; /* Handle to a text struct */

 static int Tdx = 0;        /* Text font size */
 static int Tdy = 0;

 static HWND hERROR;

 /*---------------------------------------------------------------------------
 |
 |   f u n c t i o n   d e f i n i t i o n s
 |
 \*---------------------------------------------------------------------------

 long FAR PASCAL MyWndProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL SpyProc(HWND, unsigned, WORD, LONG);

 /* HWND CreateDebugWindow (HWND,char *,BOOL); */
 void Error (char *);
 BOOL SSEqualToDS (void);

 /*
   long FAR PASCAL MsgHook1(WORD, WORD, LPMSG);
   long FAR PASCAL MsgHook2(WORD, WORD, LPMSG);
  */

 extern void FAR PASCAL KillHook();
 extern BOOL FAR PASCAL InitHook( HWND );
 extern long FAR PASCAL DebugWndProc(HWND, unsigned, WORD, LONG);
 extern HWND FAR PASCAL CreateDebugWin (HANDLE, HWND);

 extern void FAR PASCAL PassFileToDLL(int);

 /*---------------------------------------------------------------------------
 |   DlgAbout( hDlg, uiMessage, wParam, lParam )
 |
 |   Description:
 |       This function handles messages belonging to the "About" dialog box.
 |       The only message that it looks for is WM_COMMAND, indicating the use
 |       has pressed the "OK" button.  When this happens, it takes down
 |       the dialog box.
 |
 |   Arguments:
 |       hDlg            window handle of about dialog window
 |       uiMessage       message number
 |       wParam          message-dependent
 |       lParam          message-dependent
 |
 |   Returns:
 |       TRUE if message has been processed, else FALSE
 |
 \*---------------------------------------------------------------------------

 BOOL FAR PASCAL DlgAbout( hDlg, uiMessage, wParam, lParam )
 HWND     hDlg;
 unsigned uiMessage;
 WORD     wParam;
 long     lParam;
 {
     switch (uiMessage) {
         case WM_COMMAND:
             EndDialog(hDlg,TRUE);
             return(TRUE);
         case WM_INITDIALOG:
             return(TRUE);
     }
     return(FALSE);
 }


 VOID SetDlgText (hDlg,hWnd)
   HWND hDlg;
   HWND hWnd;
 {
   static char acCaption[100];
   HWND hParent;

   if (IsWindow(hWnd)) {
      acCaption[0] = '\0';
      GetWindowText (hWnd,(LPSTR)acCaption,100);
      SetDlgItemText(hDlg,ID_CAPTION,(LPSTR)acCaption);
      hParent = GetParent(hWnd);
      if (IsWindow(hParent)) {
         GetWindowText (hParent,(LPSTR)acCaption,100);
         SetDlgItemText(hDlg,ID_PARENT,(LPSTR)acCaption);
      }
      else {
         SetDlgItemText(hDlg,ID_PARENT,(LPSTR)"<NO PARENT>");
      }

      GetModuleFileName(GetWindowWord(hWnd,GWW_HINSTANCE),
                        (LPSTR)acCaption,100 );
   }
   else {
      SetDlgItemText(hDlg,ID_CAPTION,(LPSTR)"<Undefined>");
      SetDlgItemText(hDlg,ID_MODULE, (LPSTR)"<Undefined>");
      SetDlgItemText(hDlg,ID_PARENT, (LPSTR)"<Undefined>");
   }
 }

 /*---------------------------------------------------------------------------
 |   DlgSpySet( hDlg, uiMessage, wParam, lParam )
 |
 |   Description:
 |       This function handles messages belonging to the SpySet dialog box.
 |
 |   Arguments:
 |       hDlg            window handle of about dialog window
 |       uiMessage       message number
 |       wParam          message-dependent
 |       lParam          message-dependent
 |
 |   Returns:
 |       TRUE if message has been processed, else FALSE
 |
 \*---------------------------------------------------------------------------

 BOOL FAR PASCAL DlgSpySet( hDlg, uiMessage, wParam, lParam )
 HWND     hDlg;
 unsigned uiMessage;
 WORD     wParam;
 long     lParam;
 {
     static BOOL bNC;
     static BOOL bMouse;
     static HWND hSpyWnd;
     static BOOL bHook;
     static int  iCaptureState;  /* 0 = not captured, 1 = captured */

     POINT  pCursor;

     switch (uiMessage) {
         case WM_COMMAND:
             switch (wParam) {

               case ID_OK:
                 SendMessage (hSpyApp,WM_COMMAND,SPYOFF,0L);
                 gbNC     = bNC;
                 gbMouse  = bMouse;
                 ghSpyWnd = hSpyWnd;
                 gbHook   = bHook;
                 if (gbHook) hSpyWnd = NULL;
                 SendMessage (hSpyApp,WM_COMMAND,SPYON,0L);

                 /* Fall through to cancel */
               case ID_CANCEL:
                 iCaptureState++;
                 EndDialog(hDlg,TRUE);
                 return TRUE;

               case ID_MOUSE:
                 SendDlgItemMessage(hDlg,ID_MOUSE,BM_SETCHECK,bMouse ^= 1,0L);
                 return TRUE;

               case ID_NC:
                 SendDlgItemMessage(hDlg,ID_NC,BM_SETCHECK,bNC ^= 1,0L);
                 return TRUE;


 /*              case ID_ALL:
  *               SendDlgItemMessage(hDlg,ID_ALL,BM_SETCHECK,bHook ^= 1,0L);
  *               if (bHook) hSpyWnd = NULL;
  *               SetDlgText (hDlg,hSpyWnd);
  *               return TRUE;
  */
             }
             break;

         case WM_INITDIALOG:
             SendDlgItemMessage(hDlg,ID_NC   ,BM_SETCHECK,bNC   =gbNC,0L);
             SendDlgItemMessage(hDlg,ID_MOUSE,BM_SETCHECK,bMouse=gbMouse,0L);
             SendDlgItemMessage(hDlg,ID_ALL  ,BM_SETCHECK,bHook =gbHook,0L);
             hSpyWnd = ghSpyWnd;
             if (bHook) hSpyWnd = NULL;
             SetDlgText (hDlg,hSpyWnd);
             iCaptureState=0;
             return TRUE;

         /*
          * When the dialog box is being deactivated by the user clicking
          * in a window of another application find out what window and
          * steal the focus back.  If the user tries to spy on the same
          * window two times the focus is not stolen back.
          */

         case WM_ACTIVATEAPP:
             if (wParam == 0 && !iCaptureState) {
                HWND hWnd;
                GetCursorPos((LPPOINT)&pCursor);
                hWnd = WindowFromPoint(pCursor);
                if (hWnd != hSpyWnd) {
                   SetDlgText (hDlg,hWnd);
                   PostMessage(hDlg,WM_ACTIVATE,1,0L);/* Trick used to get the
                   hSpyWnd = hWnd;                    /* focus back */
                   bHook   = FALSE;
                   SendDlgItemMessage(hDlg,ID_ALL,BM_SETCHECK,bHook,0L);
                }
                return TRUE;
             }
             return FALSE;

         default:
             return FALSE;
      }
  }


 /*---------------------------------------------------------------------------
 |   MyInit( hInstance )
 |
 |   Description:
 |       This is called when the application is first loaded into
 |       memory.  It performs all initialization that doesn't need to be done
 |       once per instance.
 |
 |   Arguments:
 |       hInstance       instance handle of current instance
 |
 |   Returns:
 |       TRUE if successful, FALSE if not
 |
 \*---------------------------------------------------------------------------

 BOOL MyInit(hInstance,hPrevInstance)
    HANDLE hInstance;
    HANDLE hPrevInstance;
 {
     WNDCLASS rClass;

 /* Register a class for the main application window */

     if (!hPrevInstance) {
        rClass.hCursor        = LoadCursor(NULL,IDC_ARROW);
        rClass.hIcon          = LoadIcon(hInstance,(LPSTR)"AppIcon");
        rClass.lpszMenuName   = (LPSTR)"MyMenu";
        rClass.lpszClassName  = (LPSTR)acAppName;
        rClass.hbrBackground  = (HBRUSH)COLOR_WINDOW + 1;
        rClass.hInstance      = hInstance;
        rClass.style          = CS_HREDRAW | CS_VREDRAW;
        rClass.lpfnWndProc    = MyWndProc;
        rClass.cbWndExtra     = 0;
        rClass.cbClsExtra     = 0;

        return RegisterClass((LPWNDCLASS)&rClass);
     }
     return TRUE;
 }

 /*---------------------------------------------------------------------------
 |
 |   w i n m a i n
 |
 \*---------------------------------------------------------------------------


 /*---------------------------------------------------------------------------
 |   WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 |
 |   Description:
 |       The main procedure for the App.  After initializing, it just goes
 |       into a message-processing loop until it gets a WM_QUIT message
 |       (meaning the app was closed).
 |
 |   Arguments:
 |       hInstance       instance handle of this instance of the app
 |       hPrevInstance   instance handle of previous instance, NULL if first
 |       lpszCmdLine     ->null-terminated command line
 |       cmdShow         specifies how the window is initially displayed
 |
 |   Returns:
 |       The exit code as specified in the WM_QUIT message.
 |
 \*---------------------------------------------------------------------------

 int PASCAL WinMain( hInstance, hPrevInstance, fpcCmdLine, iCmdShow )
 HANDLE  hInstance, hPrevInstance;
 LPSTR   fpcCmdLine;
 int     iCmdShow;
 {
     MSG   rMsg;
     HWND  hWnd;
     HMENU hMenu;
     HDC   hdc;
     int   dxpScreen;
     int   dypScreen;

     /* Call initialization procedure */
     if (!MyInit(hInstance,hPrevInstance))
         return FALSE;

 /* create initial tiled window */

         hdc = CreateDC((LPSTR)"DISPLAY", NULL, NULL, NULL);
         dxpScreen = GetDeviceCaps(hdc, HORZRES);
         dypScreen = GetDeviceCaps(hdc, VERTRES);
         DeleteDC(hdc);

     /* Save instance handle for DialogBoxs */
     hInst = hInstance;

     hSpyApp = CreateWindow ((LPSTR)acAppName,
                             (LPSTR)acAppName,
                             WS_TILEDWINDOW,
                             0,           /*  x */
                             dypScreen/2, /*  y */
                             dxpScreen,   /* cx */
                             dypScreen/2, /* cy */
                             (HWND)NULL,        /* no parent */
                             (HMENU)NULL,       /* use class menu */
                             (HANDLE)hInstance, /* handle to window instance *
                             (LPSTR)NULL        /* no params to pass on */
                            );

     ShowWindow (hSpyApp,iCmdShow);

     /* Bind callback function with module instance */
     fpxProcAbout  = MakeProcInstance((FARPROC)DlgAbout,hInstance);
     fpxProcSpySet = MakeProcInstance((FARPROC)DlgSpySet,hInstance);
     fpxSpyProc    = MakeProcInstance((FARPROC)SpyProc,hInstance);
  /*
     fpxMsgHook1   = MakeProcInstance((FARPROC)MsgHook1,hInstance);
     fpxMsgHook2   = MakeProcInstance((FARPROC)MsgHook2,hInstance);
  */
     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hSpyApp,FALSE);
     ChangeMenu(hMenu,0,NULL,999,MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu,0,(LPSTR)"About...",CMDABOUT,MF_APPEND | MF_STRING);

     /*
      * Polling messages from event queue
      */

     while (GetMessage((LPMSG)&rMsg,NULL,0,0))  {
         TranslateMessage((LPMSG)&rMsg);
         DispatchMessage((LPMSG)&rMsg);
     }

     FreeProcInstance (fpxProcAbout);
     FreeProcInstance (fpxProcSpySet);
     FreeProcInstance (fpxSpyProc);
  /*
     FreeProcInstance (fpxMsgHook1);
     FreeProcInstance (fpxMsgHook2);
   */
     return((int)rMsg.wParam);
 }

 /*---------------------------------------------------------------------------
 |
 |   w i n d o w   p r o c s
 |
 \*---------------------------------------------------------------------------

 /*---------------------------------------------------------------------------
 |   MyWndProc( hWnd, uiMessage, wParam, lParam )
 |
 |   Description:
 |       The window proc for the app's main (tiled) window.  This processes al
 |       of the parent window's messages.
 |
 |   Arguments:
 |       hWnd            window handle for the parent window
 |       uiMessage       message number
 |       wParam          message-dependent
 |       lParam          message-dependent
 |
 |   Returns:
 |       0 if processed, nonzero if ignored
 |
 \*---------------------------------------------------------------------------

 long FAR PASCAL MyWndProc( hWnd, uiMessage, wParam, lParam )
 HWND     hWnd;
 unsigned uiMessage;
 WORD     wParam;
 long     lParam;
 {
         HANDLE hqel;
         QEL *pqel;
         HMENU hMenu;
         RECT  rRect;
         char rgch[32];
         char rgch2[32];

     /*
      *  if the message is less than WM_USER then it is a message to
      *  be proccessed
      */

     switch (uiMessage) {

         case WM_CREATE:
             hSpyChild = CreateDebugWin(hInst, hWnd);
             return 0L;

         case WM_INITMENU:
             return 0L;

         case WM_COMMAND:
             if (lParam == 0) {
                 switch (wParam) {
                     case SPYOFF:
                         if (gbSpyOn) {

                            KillHook();
                          /*
                            SetWindowsHook(WH_GETMESSAGE, fpxOldHook1);
                            SetWindowsHook(WH_CALLWNDPROC, fpxOldHook2);
                           */
                            gbSpyOn = FALSE;
                            hMenu = GetMenu (hWnd);
                            ChangeMenu (hMenu,SPYOFF,(LPSTR)"Spy On",SPYON,
                                        MF_CHANGE | MF_ENABLED);
                         }
                         return(0L);

                     case SPYON:
                         if (!gbSpyOn) {
                            InitHook(hSpyChild);
                          /*
                            fpxOldHook1 = SetWindowsHook(WH_GETMESSAGE, fpxMsg
                            fpxOldHook2 = SetWindowsHook(WH_CALLWNDPROC,fpxMsg
                           */
                            gbSpyOn = TRUE;
                            hMenu = GetMenu (hWnd);
                            ChangeMenu (hMenu,SPYON,(LPSTR)"Spy Off",SPYOFF,
                                        MF_CHANGE | MF_ENABLED);
                         }
                         return(0L);

                     case SPYSET:
                         DialogBox(hInst,MAKEINTRESOURCE(DLGSPY),hWnd,fpxProcS
                         return (0L);
                 }
             }
             break;

         case WM_SYSCOMMAND:
             if (wParam == CMDABOUT) {
                 DialogBox(hInst,MAKEINTRESOURCE(ABOUTBOX),hWnd,fpxProcAbout);
                 return(0L);
             }
             break;

         case WM_SIZE:
             MoveWindow (hSpyChild,0,0,LOWORD (lParam),HIWORD(lParam),TRUE);
             return 0L;

         case WM_DESTROY:
             SendMessage (hSpyApp,WM_COMMAND,SPYOFF,0L);

             PostQuitMessage(0L);   /* Kill the main window */
             return 0L;
     }
     return DefWindowProc (hWnd,uiMessage,wParam,lParam);
 }


 /*---------------------------------------------------------------------------
 |   SpyProc( hWnd, uiMessage, wParam, lParam )
 |
 |   Description:
 |       The window proc for the app being spied on
 |
 |   Arguments:
 |       hWnd            window handle for the parent window
 |       uiMessage       message number
 |       wParam          message-dependent
 |       lParam          message-dependent
 |
 |   Returns:
 |       0 if processed, nonzero if ignored
 |
 \*---------------------------------------------------------------------------

 long FAR PASCAL SpyProc( hWnd, uiMessage, wParam, lParam )
 HWND     hWnd;
 unsigned uiMessage;
 WORD     wParam;
 long     lParam;
 {
     /*
      *  This procedure is called from another task through a Data thunk and
      *  SS != DS (the SS is for the other task).  Watch out!!
      */

     PostMessage (hSpyApp,uiMessage + WM_USER,wParam,lParam);
     if (uiMessage == WM_DESTROY) {
        /*
         * The user is quitting the application being spyed on.
         * unhook the spy procedure or funny things may happen.
         */
        SendMessage (hSpyApp,WM_COMMAND,SPYOFF,0L);
        ghSpyWnd = NULL;
     }
     return CallWindowProc(OldSpyProc,hWnd,uiMessage,wParam,lParam);
 }



 /*---------------------------------------------------------------------------
 |
 |   w i n d o w   p r o c s
 |
 \*---------------------------------------------------------------------------


 /*---------------------------------------------------------------------------
 |  THIS IS NEVER CALLED.
 |  CreateDebugWindow (hWnd, pcText,bTiled)
 |
 |   Description:
 |     Creates a tiled window for the depositing of debuging messages.
 |
 |   Arguments:
 |     hWnd   - Window handle of the parent window.
 |     pcText - String to appear in the caption bar of the debuging window
 |     bTiled - FALSE => window is a popup,  Tiled otherwise.
 |
 |   Returns:
 |     A window handle of the debuging window, or NULL if a error occured.
 |
 \*---------------------------------------------------------------------------

 HWND CreateDebugWindow (hParent,pchName,bTiled)
     HWND   hParent;
     char   *pchName;
     BOOL   bTiled;
 {
     static int  iNextX = DEBUGX;
     static int  iNextY = DEBUGY;
     HWND        hWnd;

     MessageBeep(1);
     MessageBox( hParent, "We're here", NULL, MB_OK);
  /*
     hWnd = CreateDebugWin( hParent,
                            pchName,
                            (bTiled ? WS_TILED : WS_POPUP) |
                            WS_VSCROLL | WS_HSCROLL |
                            WS_CAPTION | WS_SYSMENU | WS_SIZEBOX,
                            iNextX,
                            iNextY,
                            DEBUGDX,
                            DEBUGDY
                          );
  */
     iNextX += DEBUGXINC;
     iNextY += DEBUGYINC;

     return hWnd;
 }

 static void Error (str)
 char *str;
 {
   int a = MessageBox (hERROR,(LPSTR)str,(LPSTR)NULL,MB_OKCANCEL);
   if (a == IDCANCEL) PostQuitMessage(0);
 }


 DDIRLI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\DDIRLI.C

 /*
  *  Function Name:   DlgDirList
  *  Program Name:    ddirli.c
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below allows the display of filenames and directories from
  *   the disk.  It will display the current directory and
  *   allow the user to select the filenames.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>
 #include "ddirli.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL DialogProc(HWND, unsigned, WORD, LONG);

 HANDLE   hInst;

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int   cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   HMENU      hMenu;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon     = LoadIcon(hInstance, NULL);
     wcClass.hCursor     = LoadCursor(NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)"MenuName";
     wcClass.lpszClassName  = (LPSTR)"DlgDirList";

     if (!RegisterClass(&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow("DlgDirList",
          "DlgDirList()",
          WS_OVERLAPPEDWINDOW,
          CW_USEDEFAULT,
          CW_USEDEFAULT,
          CW_USEDEFAULT,
          CW_USEDEFAULT,
          NULL,
          NULL,
          hInstance,
          NULL);

   hInst = hInstance;
   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);
   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return msg.wParam;
   }

 long FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       if (wParam == IDM_1)
   {
   FARPROC lpprocDialogBox;
   lpprocDialogBox = MakeProcInstance ((FARPROC) DialogProc, hInst);
   DialogBox (hInst, MAKEINTRESOURCE(DIALOGID), hWnd, lpprocDialogBox);
   FreeProcInstance ((FARPROC) lpprocDialogBox);
   }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
     }
   return(0L);
   }

 /* Window procedure for the dialog box */
 BOOL FAR PASCAL DialogProc (hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   BOOL     bListed;
   char     str[128];

   switch (message)
     {
     case WM_INITDIALOG:
       {
       bListed = DlgDirList(hDlg, "*.*", ID_LISTBOX, NULL, 0x4010);
       if (!bListed)
   {
   MessageBox(NULL, (LPSTR)"DlgDirList failed", (LPSTR)"ERROR", MB_ICONHAND);
   return FALSE;
   }
       SetDlgItemText(hDlg, ID_EDIT, (LPSTR)"");
       return TRUE;
       break;
       }
     case WM_COMMAND:
       {
       switch (wParam)
   {
   case ID_LISTBOX:
     if ((HIWORD(lParam)) == LBN_SELCHANGE)
       {
       DlgDirSelect(hDlg, (LPSTR)str, ID_LISTBOX);
       SetDlgItemText(hDlg, ID_EDIT, (LPSTR)str);
       return TRUE;
       }
     break;
   case IDCANCEL:
     EndDialog(hDlg, TRUE);
     break;
   default:
     return FALSE;
   }
       }
     default:
       return FALSE;
     }
   return TRUE;
   }


 DDIRSEL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\DDIRSEL.C

 /*
  *  Function Name:   DlgDirSelect
  *  Program Name:    ddirsel.c
  *  Author:          bertm
  *  Date Completed:  2-Feb-88
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This program allows the user to select filenames or directories from
  *   the list box. The program below will display the current directory
  *   and allow the user to select the filenames.  The program will not
  *   select directories (demonstrating the return value).
  *
  *   Microsoft Product Support Services
  *   Windows Version 2.0 function demonstration application
  *   Copyright (c) Microsoft 1988
  *
  */

 #include "windows.h"
 #include "ddirsel.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE   hInst;

 /**************************************************************************/

 /* Window procedure for the dialog box */
 BOOL FAR PASCAL DialogProc (hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
   char  str[128];

   switch (message)
   {
     case WM_INITDIALOG:
       DlgDirList(hDlg, (LPSTR) "*.*", ID_LISTBOX, NULL, 0x4010);
       SetDlgItemText(hDlg, ID_EDIT, (LPSTR) "");
       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
       {
         case ID_LISTBOX:
           switch (HIWORD(lParam))
           {
             case LBN_SELCHANGE:
                                          /* filenames only chosen   */
              if (!DlgDirSelect(hDlg, (LPSTR)str, ID_LISTBOX))
                SetDlgItemText(hDlg, ID_EDIT, (LPSTR)str);
               return TRUE;
               break;

             default:
               return FALSE;
           }
         case IDCANCEL:
           EndDialog(hDlg, TRUE);
           break;

         default:
           return FALSE;
       }
     default:
       return FALSE;
   }
   return TRUE;              /*  return TRUE if message is processed by us  */
 }

 /**************************************************************************/

 void CALL_DlgDirSelect(hWnd)
 HWND   hWnd;
 {
   FARPROC lpprocDialogBox;
                     /*  Bind callback function with module instance  */
     lpprocDialogBox = MakeProcInstance ((FARPROC) DialogProc, hInst);
                     /*  Create a modal dialog box  */
     DialogBox (hInst, MAKEINTRESOURCE(DIALOGID), hWnd, lpprocDialogBox);
     FreeProcInstance ((FARPROC) lpprocDialogBox);

 return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)"MenuName";
     wcClass.lpszClassName  = (LPSTR)"DlgDirSelect";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"DlgDirSelect",
                         (LPSTR)"DlgDirSelect()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

      hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }
     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
       case WM_COMMAND:
         switch (wParam)
         {
           case IDM_1:
             CALL_DlgDirSelect(hWnd);
             break;

           default:
             return DefWindowProc( hWnd, message, wParam, lParam );
             break;
         }

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         ValidateRect(hWnd, (LPRECT) NULL);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }




 DECARET.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\DECARET.C

 /*
  *  Function Name:   DestroyCaret
  *  Program Name:    decaret.c
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below will display a caret and then destroy it.
  *
  *   Microsoft Product Support Services
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int  cmdShow;
 {
   MSG       msg;
   HWND       hWnd;
   HMENU      hMenu;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
   {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon     = LoadIcon(hInstance, NULL);
     wcClass.hCursor     = LoadCursor(NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DestroyCaret";

     if (!RegisterClass(&wcClass))
       return FALSE;
   }

   hWnd = CreateWindow("DestroyCaret",
       "DestroyCaret()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return msg.wParam;
 }


 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_PAINT:
     {
       BeginPaint(hWnd, &ps);
       if (!IsIconic (hWnd))
       {
   CreateCaret (hWnd, NULL, 10, 20);
   SetCaretPos (40, 40);
   ShowCaret (hWnd);
   MessageBox(hWnd,
       "Caret shown, press return to destroy",
       "DestroyCaret", MB_OK);
   DestroyCaret();
       }
       ValidateRect(hWnd, NULL);
       EndPaint(hWnd, &ps);
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return(0L);
 }




 DEMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\DEMENU.C

 /*  Function Name:   DestroyMenu
  *
  *  Description:
  *   The program below will create a menu.  When the menuitem is selected,
  *   that menu will be destroyed and a new menu will be created.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 HMENU hMenu;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"DestroyMenu";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, "Add MenuItem", 100, MF_APPEND);

   hWnd = CreateWindow ( (LPSTR)"DestroyMenu",
                       (LPSTR)"DestroyMenu ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,        /* no parent */
                       (HMENU)hMenu,      /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case 100:
           SetMenu (hWnd, NULL);  /*  No Menu for the Window while we play  */
           DestroyMenu (hMenu);   /*  Trash the Menu  */
           hMenu = CreateMenu (); /*  Create a new one  */
           ChangeMenu (hMenu, NULL, "Delete Extra MenuItem  ", 105, MF_APPEND)
           ChangeMenu (hMenu, NULL, "  Extra MenuItem", 110, MF_APPEND);
           SetMenu (hWnd, hMenu);  /*  Change the menu for the window  */
           break;

         case 105:
           SetMenu (hWnd, NULL);
           DestroyMenu (hMenu);
           hMenu = CreateMenu ();
           ChangeMenu (hMenu, NULL, "Add MenuItem", 100, MF_APPEND);
           SetMenu (hWnd, hMenu);
           break;

         case 110:
           MessageBox (GetFocus(), "Extra MenuItem Was Selected",
                       "Extra MenuItem", MB_OK | MB_ICONEXCLAMATION);
           break;

         default:
           return DefWindowProc (hWnd, message, wParam, lParam);
         }
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 DEMETAFI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\DEMETAFI.C

 /*
  *  Function Name:   DeleteMetaFile
  *  Program Name:    demetafi.c
  *  Special Notes:   Needs CRMETAFI.MET file to run.
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below used to free up memory the metafile has been using.
  *   The metafile may be recalled from the disk into memory by using the
  *   GetMetaFile function.  The program below draws a rectangle, then
  *   releases the metafile handle.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int  cmdShow;
 {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
   {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon     = LoadIcon(hInstance, NULL);
     wcClass.hCursor     = LoadCursor(NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"DeleteMetaFile";

     if (!RegisterClass((LPWNDCLASS) & wcClass))
       return FALSE;
   }

   hWnd = CreateWindow("DeleteMetaFile",
       "DeleteMetaFile()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);
   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return msg.wParam;
 }


 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   PAINTSTRUCT ps;
   HDC        hDC;
   HANDLE      hMetaFile;

   switch (message)
   {
   case WM_PAINT:
     {
       BeginPaint(hWnd, &ps);
       hDC = ps.hdc;
       hMetaFile = GetMetaFile("demetafi.met");
       PlayMetaFile(hDC, hMetaFile);
       if (!DeleteMetaFile(hMetaFile))
   MessageBox(hWnd, "DeleteMetaFile failed", "ERROR", MB_ICONHAND);
       else
   TextOut(hDC, 20, 20, "Metafile handle released", 24);
       ValidateRect(hWnd, NULL);
       EndPaint(hWnd, &ps);
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return(0L);
 }




 DEWINDOW.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\DEWINDOW.C

 /*
  *  Function Name:   DestroyWindow
  *  Program Name:    dewindow.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This program will destroy the window, leaving just a message box.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int   cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon     = LoadIcon(hInstance, NULL);
     wcClass.hCursor     = LoadCursor(NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DestroyWindow";

     if (!RegisterClass(&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow("DestroyWindow",
           "DestroyWindow()",
           WS_OVERLAPPEDWINDOW,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           NULL,
           NULL,
           hInstance,
           NULL);

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);
   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return msg.wParam;
   }

 long FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;
   BOOL        bDestroyed;
   HDC        hDC;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint(hWnd, &ps);
       hDC=ps.hdc;
       TextOut(hDC, 10, 10, "End program to demonstrate", 26);
       ValidateRect(hWnd, NULL);
       EndPaint(hWnd, &ps);
       break;
     case WM_CLOSE:
       bDestroyed = DestroyWindow(hWnd);
       MessageBox(hWnd, "Window was just destroyed", "DestroyWindow", MB_OK);
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     case WM_DESTROY:
       PostQuitMessage(0);
       break;
     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
     }
   return(0L);
   }


 DIABOX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\DIABOX.C


 #include <windows.h>
 #include <string.h>
 #include "diabox.h"

 BOOL FAR PASCAL InitDiabox (HANDLE, HANDLE, int);
 LONG FAR PASCAL DiaboxWindowProc   (HANDLE, unsigned, WORD, LONG);
 BOOL FAR PASCAL DialogBoxWindowProc (HANDLE, unsigned, WORD, LONG); /* added
 int     NEAR writeGMem (HANDLE, WORD, BYTE *, WORD);

 HANDLE  hDTemplate;
 HANDLE  hInst;
 FARPROC lpDlgTest;
 HWND    hDlgTest;
 BOOL    nModeless;
 BOOL    bResult;

 struct dtHdrType   {
   LONG  dtStyle;
   BYTE  dtItemCount;
   int  dtX;
   int  dtY;
   int  dtCX;
   int  dtCY;
   char  dtResourceName[1];
   char  dtClassName[1];
   char  dtCaptionText[1];
   };

 #define DTHDR    struct dtHdrType

 struct dtItmType   {
   int  dtilX;
   int  dtilY;
   int  dtilCX;
   int  dtilCY;
   int  dtilID;
   LONG  dtilWindowStyle;
   BYTE  dtilControlClass;
   char  dtilText[1];
   };

 #define DTITM    struct dtItmType

 DTHDR    dtHdr;
 DTITM    dtItm;
 WORD     wByteCount;
 BYTE     work[256];

 /*  Forward references and type checking */

 BOOL DisplayDialogBox (HWND);

 /**************************************************************************/

 int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;

   if (hPrevInstance)   /* do not allow more than one instance */
     return FALSE;

   InitDiabox (hInstance, hPrevInstance, cmdShow);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     if (nModeless == TRUE)
       {
       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
       }
     else
       {
       if ( (hDlgTest == NULL) || !IsDialogMessage (hDlgTest, (LPMSG) & msg))
         {
         TranslateMessage ( (LPMSG) & msg);
         DispatchMessage ( (LPMSG) & msg);
         }
       }
     }
   return (msg.wParam);
   }

 /*******************************   initialization   ***********************/
 BOOL FAR PASCAL InitDiabox (hInstance, hPrevInstance, cmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 int      cmdShow;
   {
   WNDCLASS  wcDiaboxClass;
   HWND      hWnd;

   wcDiaboxClass.lpszClassName = (LPSTR) "Diabox";
   wcDiaboxClass.hInstance     = hInstance;
   wcDiaboxClass.lpfnWndProc   = DiaboxWindowProc;
   wcDiaboxClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcDiaboxClass.hIcon         = NULL;
   wcDiaboxClass.lpszMenuName  = (LPSTR) "diabox";             /* menu added
   wcDiaboxClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcDiaboxClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcDiaboxClass.cbClsExtra    = 0;
   wcDiaboxClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcDiaboxClass);
   hWnd = CreateWindow ( (LPSTR) "Diabox",
       (LPSTR) "DialogBox",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,
       (HMENU)NULL,
       (HANDLE)hInstance,
       (LPSTR)NULL
      );

   hInst = hInstance;       /*  instance saved for dialog box  */

   ShowWindow   (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }


 /*********************   window procedure - process messages   *************/

 LONG FAR PASCAL DiaboxWindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       switch (wParam)
         {
         case IDDBOX:
           nModeless = FALSE;
           bResult = DisplayDialogBox (hWnd);
           break;

         case IDDBOX2:
           nModeless = TRUE;
           bResult = DisplayDialogBox (hWnd);
           break;

         default:
           return DefWindowProc (hWnd, message, wParam, lParam);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }


 /***************************************************************************/
 BOOL DisplayDialogBox (hWnd)
 HWND   hWnd;
   {
   LPSTR    lpDTemplate;

   if (hDlgTest != NULL)
     return (FALSE);

   if (! (hDTemplate = GlobalAlloc (GMEM_MOVEABLE, (DWORD) sizeof (DTHDR))))
     return (FALSE);

   wByteCount = 0;
   dtHdr.dtStyle           = WS_POPUP | WS_VISIBLE | WS_BORDER | WS_CAPTION;
   dtHdr.dtItemCount       = 4;
   dtHdr.dtX               = 10;
   dtHdr.dtY               = 10;
   dtHdr.dtCX              = 200;
   dtHdr.dtCY              = 100;
   dtHdr.dtResourceName[0] = 0;
   dtHdr.dtClassName[0]    = 0;

   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtHdr, sizeof (DTHDR) -
     return (FALSE);
   wByteCount += sizeof (DTHDR) - 1;

   strcpy (work, "Template Test");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

 /* add OK BUTTON item */

   dtItm.dtilX            = 30;
   dtItm.dtilY            = 60;
   dtItm.dtilCX           = 32;
   dtItm.dtilCY           = 12;
   dtItm.dtilID           = 0x0300;
   dtItm.dtilWindowStyle  = BS_DEFPUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISI
   dtItm.dtilControlClass = 0x80; /* BUTTON */
   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   strcpy (work, "OK");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);
   wByteCount += 1;

 /* add CANCEL BUTTON item */

   dtItm.dtilX            = 70;
   dtItm.dtilY            = 60;
   dtItm.dtilCX           = 32;
   dtItm.dtilCY           = 12;
   dtItm.dtilID           = 0x0400;
   dtItm.dtilWindowStyle  = BS_PUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE
   dtItm.dtilControlClass = 0x80; /* BUTTON */
   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   strcpy (work, "Cancel");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);
   wByteCount += 1;

 /* add EDIT item */

   dtItm.dtilX            = 30;
   dtItm.dtilY            = 40;
   dtItm.dtilCX           = 32;
   dtItm.dtilCY           = 12;
   dtItm.dtilID           = 0x0200;
   dtItm.dtilWindowStyle  = ES_LEFT | WS_TABSTOP | WS_CHILD | WS_BORDER | WS_V
   dtItm.dtilControlClass = 0x81; /* EDITCODE */
   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   strcpy (work, "Edit");
   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);
   wByteCount += 1;

 /* add MESSAGE item */

   dtItm.dtilX     = 30;
   dtItm.dtilY     = 20;
   dtItm.dtilCX    = 100;
   dtItm.dtilCY    = 8;
   dtItm.dtilID    = 0x0100;
   dtItm.dtilWindowStyle = SS_LEFT | WS_CHILD | WS_VISIBLE;
   dtItm.dtilControlClass = 0x82; /* STATICCODE */
   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) -
     return (FALSE);
   wByteCount += sizeof (DTITM) - 1;

   if (nModeless == FALSE)
     strcpy (work, "Modal DialogBox");
   else
     strcpy (work, "Modeless DialogBox");

   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
     return (FALSE);
   wByteCount += strlen (work) + 1;

   work[0] = 0;
   if (!writeGMem (hDTemplate, wByteCount, work, 1))
     return (FALSE);

   lpDlgTest = MakeProcInstance ( (FARPROC) DialogBoxWindowProc, hInst);

   if (nModeless == FALSE)
     {
     hDlgTest = DialogBoxIndirect (hInst, hDTemplate, hWnd, lpDlgTest);
     FreeProcInstance ( (FARPROC) lpDlgTest);
     hDlgTest = NULL;
     }
   else
     {
     lpDTemplate = GlobalLock (hDTemplate);
     hDlgTest = CreateDialogIndirect (hInst, lpDTemplate, hWnd, lpDlgTest);
     GlobalUnlock (hDTemplate);
     }
   return (TRUE);
   }

 /**************************************************************************/
 BOOL FAR PASCAL DialogBoxWindowProc (hDlg, message, wParam, lParam)
 HWND      hDlg;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   char  TempEdit[24];

   switch (message)
     {
     case WM_INITDIALOG:
   /* SetFocus to first control that is not a static or group box */
       SetFocus (GetDlgItem (hDlg, 0x0200));
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case 0x0100: /* static */
         case 0x0200: /* edit   */
           break;
         case 0x0300: /* ok     */
           GetDlgItemText (hDlg, 0x0200, TempEdit, 24);
           MessageBox (GetFocus (), (LPSTR)TempEdit,
                      (LPSTR)"Edit Control Contains", MB_OK);

           /*  No Break Here... We want to end the Dialog Box  */
         case 0x0400: /* cancel */
           if (nModeless == FALSE)
             EndDialog (hDlg, TRUE);
           else
             {
             DestroyWindow (hDlg);
             hDlgTest = NULL;
             }
           return (TRUE);
         default:
           return (TRUE);
         }           /* end wParam switch */
       break;      /* end command */

     default:
       return (FALSE);
     }                 /* end message switch */
   return (FALSE);
   }

 /****************************************************************************
 int     NEAR writeGMem (hData, offset, data, length)
 HANDLE  hData;
 WORD    offset;
 BYTE    *data;
 WORD    length;
   {
   HANDLE  hNewData;
   LPSTR   lpDstData;
   int     n;

   if (offset + length > (WORD)GlobalSize (hData))
     {
     if (! (hNewData = GlobalReAlloc (hData, (DWORD) offset + length, GMEM_MOV
       GlobalFree (hData);
     hDTemplate = hNewData;
     }

   if (lpDstData = GlobalLock (hData))
     {
     lpDstData = lpDstData + offset;
     for (n = 0; n < length; n++)
       *lpDstData++ = *data++;
     GlobalUnlock (hData);
     return (TRUE);
 /* return (lpDstData); */  /* return new offset position */
     }
   return (FALSE);
   }


 DIABOXIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\DIABOXIN.C

 /*
  *
  *  DialogBoxIndirect
  *
  *  This program demonstrates the use of the function DialogBoxIndirect.
  *  It allows the user to create a modal dialogbox on the fly. Memory is
  *  dynamically allocated so that the structure will accomadate variable
  *  string sizes.
  */



 #include <windows.h>
 #include "diaboxin.h"

 BOOL FAR PASCAL InitDiabox ( HANDLE , HANDLE , int );
 long FAR PASCAL DiaboxWindowProc ( HANDLE , unsigned , WORD , LONG );
 BOOL FAR PASCAL DialogBoxWindowProc (HANDLE, unsigned, WORD, LONG); /* added

 HANDLE hInst;
 FARPROC lpDlgTest;
 HWND hDlgTest;

 #define DTHDR        struct dtHdrType

 struct dtHdrType
 {
    LONG  dtStyle;
    BYTE  dtItemCount;
    int   dtX;
    int   dtY;
    int   dtCX;
    int   dtCY;
    char  dtResourceName[7];
    char  dtClassName[1];
    char  dtCaptionText[1];
 };

 #define DTITM        struct dtItmType

 struct dtItmType
 {
    int   dtilX;
    int   dtilY;
    int   dtilCX;
    int   dtilCY;
    int   dtilID;
    LONG  dtilWindowStyle;
    BYTE  dtilControlClass;
    char  dtilText[1];
 };


 /**************************************************************************/

 int PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , cmdShow )
 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int cmdShow;
   {
   MSG  msg;

   InitDiabox (hInstance, hPrevInstance, cmdShow );
   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
     }
   exit(msg.wParam);
   }

 /*******************************   initialization   ***********************/

 BOOL FAR PASCAL InitDiabox (hInstance , hPrevInstance , cmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 int cmdShow;
   {
   WNDCLASS  wcDiaboxClass;
   HWND  hWnd;

   wcDiaboxClass.lpszClassName = (LPSTR) "Diabox";
   wcDiaboxClass.hInstance     = hInstance;
   wcDiaboxClass.lpfnWndProc   = DiaboxWindowProc;
   wcDiaboxClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
   wcDiaboxClass.hIcon         = NULL;
   wcDiaboxClass.lpszMenuName  = (LPSTR) "diabox";             /* menu added
   wcDiaboxClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcDiaboxClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcDiaboxClass.cbClsExtra    = 0;
   wcDiaboxClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) &wcDiaboxClass);
   hWnd = CreateWindow((LPSTR) "Diabox",
                       (LPSTR) "DialogBoxIndirect",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,
                       (HMENU)NULL,
                       (HANDLE)hInstance,
                       (LPSTR)NULL
                      );

   hInst = hInstance;                    /*  instance saved for dialog box  */

   ShowWindow (hWnd , cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }

 /*********************   window procedure - process messages   *************/

 long FAR PASCAL DiaboxWindowProc (hWnd , message , wParam , lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_COMMAND:
         switch (wParam)
         {
         case IDDBOX:
             DisplayDialogBox(hWnd);
             break;
         default:
             return DefWindowProc(hWnd, message, wParam, lParam);
             break;
         }

     case WM_PAINT:
         BeginPaint (hWnd, (LPPAINTSTRUCT)&ps);
         EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
         break;

     case WM_DESTROY:
         PostQuitMessage(0);
         break;

     default:
         return( DefWindowProc( hWnd , message , wParam , lParam ) );
         break;
     }
   return( 0L );
   }

 /***************************************************************************/

 DisplayDialogBox(hWnd)
 HWND   hWnd;
 {

    DTHDR    dtHdr;
    DTITM    dtItm;
    HANDLE   hDTemplate;
    LPSTR    lpDTemplate;
    WORD     wByteCount;
    BYTE     work[256];
    static   char     name[7] = "diabox";

    if(hDlgTest != NULL)
       return(FALSE);

    if(!(hDTemplate = GlobalAlloc(GMEM_MOVEABLE, (DWORD) sizeof(DTHDR))))
       return(FALSE);
    wByteCount = 0;

    dtHdr.dtStyle     = WS_POPUP | WS_VISIBLE | WS_BORDER | WS_CAPTION |
                        WS_SIZEBOX | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
    dtHdr.dtItemCount = 2;
    dtHdr.dtX         = 10;
    dtHdr.dtY         = 10;
    dtHdr.dtCX        = 200;
    dtHdr.dtCY        = 100;
    strcpy(dtHdr.dtResourceName, name);
    dtHdr.dtClassName[0]    = 0;
    if(!writeGMem(hDTemplate, wByteCount, (BYTE *) &dtHdr, sizeof(DTHDR)-1))
       return(FALSE);
    wByteCount += sizeof(DTHDR)-1;

    strcpy(work, "Howdy !!!");
    if(!writeGMem(hDTemplate, wByteCount, work, strlen(work)+1))
       return(FALSE);
    wByteCount += strlen(work)+1;

 /* add BUTTON item */

    dtItm.dtilX     = 30;
    dtItm.dtilY     = 50;
    dtItm.dtilCX    = 32;
    dtItm.dtilCY    = 12;
    dtItm.dtilID    = 0x0200;
    dtItm.dtilWindowStyle = BS_DEFPUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISI
    dtItm.dtilControlClass = 0x80;
    if(!writeGMem(hDTemplate, wByteCount, (BYTE *) &dtItm, sizeof(DTITM)-1))
       return(FALSE);
    wByteCount += sizeof(DTITM)-1;

    strcpy(work, "OK");
    if(!writeGMem(hDTemplate, wByteCount, work, strlen(work)+1))
       return(FALSE);
    wByteCount += strlen(work)+1;

    work[0] = 0;
    if(!writeGMem(hDTemplate, wByteCount, work, 1))
       return(FALSE);
    wByteCount += 1;

 /* add MESSAGE item */

    dtItm.dtilX     = 30;
    dtItm.dtilY     = 20;
    dtItm.dtilCX    = 100;
    dtItm.dtilCY    = 8;
    dtItm.dtilID    = 0x0100;
    dtItm.dtilWindowStyle = SS_LEFT | WS_CHILD | WS_VISIBLE;
    dtItm.dtilControlClass = 0x82;
    if(!writeGMem(hDTemplate, wByteCount, (BYTE *) &dtItm, sizeof(DTITM)-1))
       return(FALSE);
    wByteCount += sizeof(DTITM)-1;

    strcpy(work, "Modal DialogBox");
    if(!writeGMem(hDTemplate, wByteCount, work, strlen(work)+1))
       return(FALSE);
    wByteCount += strlen(work)+1;

    work[0] = 0;
    if(!writeGMem(hDTemplate, wByteCount, work, 1))
       return(FALSE);

    lpDlgTest = MakeProcInstance((FARPROC) DialogBoxWindowProc, hInst);

    hDlgTest = DialogBoxIndirect (hInst, hDTemplate, hWnd, lpDlgTest);
                                              /*  function demonstrated  */
    if (hDlgTest == -1)
      MessageBox (NULL,(LPSTR)"DialogBoxIndirect failed",
                 (LPSTR) "error",MB_ICONHAND);
    FreeProcInstance ((FARPROC) lpDlgTest);
    hDlgTest = NULL;
   return(TRUE);

 }
 /**************************************************************************/

 BOOL FAR PASCAL DialogBoxWindowProc (hDlg, message, wParam, lParam)
 HWND      hDlg;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
 {
   switch(message)
   {
    case WM_COMMAND:
       switch(wParam)
       {
       case 0x0100:
       case 0x0200:
          break;
       default:
          return(TRUE);
       }
       break;
    default:
       return(FALSE);
    }

    EndDialog (hDlg, TRUE);
    return(TRUE);
 }


 /****************************************************************************

 BOOL NEAR writeGMem(hData, offset, data, length)
 HANDLE  hData;
 WORD    offset;
 BYTE    *data;
 WORD    length;
 {
    HANDLE  hNewData;
    LPSTR   lpDstData;
    int     n;

    if(offset+length > GlobalSize(hData))
    {
       if(!(hNewData = GlobalReAlloc(hData, (DWORD) offset+length, GMEM_MOVEAB
          GlobalFree(hData);

       hData = hNewData;
    }

    if(lpDstData = GlobalLock(hData))
    {
       lpDstData = lpDstData + offset;
       for (n = 0 ; n < length ; n++)
          *lpDstData++ = *data++;
       GlobalUnlock(hData);
       return(TRUE);
    }

    return(FALSE);
 }






 DIMESS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\DIMESS.C

 /*
  *  Function Name:   DispatchMessage
  *
  *  Description:
  *   This function passes all messages from the main procedure (WinMain) to
  *   the window procedure.  It passes the message in the MSG structure to the
  *   window function of the specified window.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);



 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int  cmdShow;
 {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
   {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon     = LoadIcon(hInstance, NULL);
     wcClass.hCursor     = LoadCursor(NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DispatchMessage";

     if (!RegisterClass(&wcClass))
       return FALSE;
   }

   hWnd = CreateWindow("DispatchMessage",
       "DispatchMessage()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);
   MessageBox(hWnd, "DispatchMessage working in loop",
       "DispatchMessage", MB_ICONASTERISK);
   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return msg.wParam;
 }


 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
   {
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return(0L);
 }




 DLGINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\DLGINT.C

 /*
  *
  *  SetDlgItemInt
  *  This program demonstrates the use of the function SetDlgItemInt.
  *  It sets the text of a dialog item (control) to the string representation
  *  of an integer value.
  */

 #include "windows.h"
 #include "dlgint.h"

 HANDLE   hInst;
 FARPROC  lpprocEdit;

 long    FAR PASCAL SampleWndProc (HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL EditProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = SampleWndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.hIcon          = LoadIcon (hInstance, "WindowIcon");
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.lpszMenuName   = MAKEINTRESOURCE (DIALOGMENU);
     wcClass.lpszClassName  = "dlgint";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }
   hWnd = CreateWindow ("dlgint",
                       "Sending Integers",
                       WS_OVERLAPPEDWINDOW,
                       50,
                       50,
                       600,
                       250,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);
   hInst = hInstance;
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }

 long    FAR PASCAL SampleWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       if (wParam == ID_DIALOG)
         {
         lpprocEdit = MakeProcInstance ( (FARPROC) EditProc, hInst);
         DialogBox (hInst, MAKEINTRESOURCE (EDITBOX), hWnd, lpprocEdit);
         FreeProcInstance ( (FARPROC) lpprocEdit);
         }
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 BOOL FAR PASCAL EditProc (hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_INITDIALOG:
       SetDlgItemInt (hDlg, ID_EDITBOX, 12345, (BOOL)FALSE);
       return TRUE;
       break;

     case WM_COMMAND:
       if (wParam == IDOK)
         {
         EndDialog (hDlg, TRUE);
   return TRUE;
         }
       break;

     default:
       return FALSE;
     }
   return TRUE;
   }


 DLGTEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\DLGTEXT.C

 /*
  *  SetDlgItemText
  *  This program demonstrates the use of the function SetDlgItemText.
  *  It sets the caption or text of a dialog item (control) in the dialog
  *  box.
  */

 #include "windows.h"
 #include "dlgtext.h"

 HANDLE hInst;
 FARPROC lpprocEdit;

 long    FAR PASCAL SampleWndProc (HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL EditProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = SampleWndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hIcon          = LoadIcon (hInstance, "WindowIcon");
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = MAKEINTRESOURCE (DIALOGMENU);
     wcClass.lpszClassName  = "dlgtext";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("dlgtext",
                       (LPSTR)"Sending Text",
                       WS_OVERLAPPEDWINDOW,
                       50,
                       50,
                       600,
                       250,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   hInst = hInstance;
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }

 long    FAR PASCAL SampleWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       if (wParam == ID_DIALOG)
         {
         lpprocEdit = MakeProcInstance ( (FARPROC) EditProc, hInst);
         DialogBox (hInst, MAKEINTRESOURCE (EDITBOX), hWnd, lpprocEdit);
         FreeProcInstance ( (FARPROC) lpprocEdit);
         }
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }

 BOOL FAR PASCAL EditProc (hDlg, message, wParam, lParam)
 HWND    hDlg;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   switch (message)
     {
     case WM_INITDIALOG:
       SetDlgItemText (hDlg, ID_EDITBOX, (LPSTR)"Text Received!!");
       return TRUE;
       break;

     case WM_COMMAND:
       if (wParam == IDOK)
         {
         EndDialog (hDlg, TRUE);
   return TRUE;
   break;
         }
       break;

     default:
       return FALSE;
     }
   return TRUE;
   }


 DPTOLP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIENT\DPTOLP.C

 /*
  *  Function Name:   DPtoLP
  *
  *  Description:
  *   This program will take the client area in MM_TEXT mode (device
  *   coordinates), store the client area size in a POINT data structure,
  *   change the map mode to MM_LOENGLISH, then convert the points to
  *   MM_LOENGLISH (logical coordinates).  The size of the client area
  *   is then displayed for both map modes.
  */

 #include "windows.h"
 #include "stdio.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DPtoLP";

     if (!RegisterClass ( (LPWNDCLASS) & wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("DPtoLP",
                       "DPtoLP ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }


 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   PAINTSTRUCT ps;
   RECT        ClientRect;
   POINT       Points[1];
   char        szString1[80], szString2[80];
   int         nLength[2];

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, &ps);
       GetClientRect (hWnd, &ClientRect);
       Points[0].x = ClientRect.right;
       Points[0].y = ClientRect.bottom;
       SetMapMode (ps.hdc, MM_LOENGLISH);
       if (!DPtoLP (ps.hdc, Points, 1))
         {
         MessageBeep (0);
   break;
         }
       SetMapMode (ps.hdc, MM_TEXT);
       nLength[0] = sprintf (szString1,
           "Client area in MM_LOENGLISH mode: x=%d   y=%d",
           Points[0].x,
           Points[0].y);
       nLength[1] = sprintf (szString2,
           "Client area in MM_TEXT mode (pixels): x=%d   y=%d",
           ClientRect.right,
           ClientRect.bottom);
       TextOut (ps.hdc, 10, 10, szString1, nLength[0]);
       TextOut (ps.hdc, 30, 30, szString2, nLength[1]);
       ValidateRect (hWnd, NULL);
       EndPaint (hWnd, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 DRICON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ICON\DRICON.C

 /*
  *  Function Name:   DrawIcon
  *
  *  Description:
  *   The program below will display a stock icon.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DrawIcon";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("DrawIcon",
                       "DrawIcon ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }

 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   PAINTSTRUCT ps;
   HANDLE      hIcon;
   BOOL        bDrawn;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       hIcon = LoadIcon ( (HANDLE) NULL, IDI_EXCLAMATION);
       if (!DrawIcon (ps.hdc, 50, 50, hIcon))
         {
         MessageBeep (0);
   return FALSE;
         }
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 DRMENUBR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\DRMENUBR.C

 /*
  *  Function Name:   DrawMenuBar
  *
  *  Description:
  *   The program below will redraw a window's menu, usually with
  *   modifications by ChangeMenu.  DrawMenuBar gives the same result as
  *   SetMenu, but DrawMenuBar cannot initially create the menu bar like
  *   SetMenu can.  The program below uses SetMenu to set and display
  *   'Heading1'and uses DrawMenuBar to display the addition 'Heading2'
  *   by ChangeMenu.
  *
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DrawMenuBar";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("DrawMenuBar",
       "DrawMenuBar ()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }


 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   HMENU      hCurrentWindowMenu;
   unsigned   wIDItem;

   switch (message)
     {
     case WM_CREATE:
       hCurrentWindowMenu = CreateMenu ();
       ChangeMenu (hCurrentWindowMenu, NULL, "Heading1", wIDItem,
                   MF_APPEND | MF_BYCOMMAND | MF_STRING);
       SetMenu (hWnd, hCurrentWindowMenu);
       ChangeMenu (hCurrentWindowMenu, NULL, "Heading2", wIDItem,
                   MF_APPEND | MF_BYCOMMAND | MF_STRING);
       DrawMenuBar (hWnd);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;
     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 DRTEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\DRTEXT.C

 /*
  *  Function Name:   DrawText
  *
  *  Description:
  *   This program will put text into the user rectangle with some control
  *   over the method of formatting the text.
  */

 #include "windows.h"
 #include "stdio.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG       msg;
   HWND       hWnd;
   WNDCLASS   wcClass;

   if (!hPrevInstance)
     {
     wcClass.style     = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance     = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "DrawText";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("DrawText",
       "DrawText ()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);
   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }

 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;
   HDC        hDC;
   RECT        RectDraw;
   char  szString[80];
   int  nLength;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       hDC = ps.hdc;
       RectDraw.left   = 10;
       RectDraw.top   = 10;
       RectDraw.right   = 150;
       RectDraw.bottom   = 70;
       nLength = sprintf (szString, "Wow!  Some Text!");
       DrawText (hDC, szString, nLength, &RectDraw, DT_LEFT | DT_WORDBREAK);
       ValidateRect (hWnd, NULL);
       EndPaint (hWnd, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 DSPYDLL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DDE\DDESPY\DSPYDLL.C

 #include "windows.h"
 #include "winexp.h"
 #include "ddespy.h"
 #include "dde.h"

 #define MENU

 /*---------------------------------------------------------------------------
 |
 |   g l o b a l   v a r i a b l e s
 |
 \*---------------------------------------------------------------------------
 /* NOTICE: The message structure for WH_CALLWNDPROC is "upside down"
            compared to the normal MSG structure. */
 typedef struct mymsg {
     LONG lParam;
     WORD wParam;
     WORD message;
     HWND hwnd;
 } MYMSG;
 typedef MYMSG FAR *LPMYMSG;

 /* Static definitions */
 static  FARPROC fpxMsgHook1;
 static  FARPROC fpxMsgHook2;
 static  FARPROC fpxOldHook1;
 static  FARPROC fpxOldHook2;

 FARPROC lplpfnNextHook1;
 FARPROC lplpfnNextHook2;
 HWND    hSpyChild;
 char    szTemp[30];
 char    szTemphWnd[30];
 static  int Tdx = 0;        /* Text font size */
 static  int Tdy = 0;

 struct TEXT_STRUCT {
     int  iFirst;                  /* First line in que */
     int  iCount;                  /* Number of lines in que */
     int  iTop;                    /* Line at top of window */
     int  iLeft;                   /* X offset of the window */
     char *Text[MAXLINES];         /* Que of Text in window */
     int  Len[MAXLINES];           /* String Length of text */
     int  MaxLen;                  /* Max String Length */
 };

 typedef struct TEXT_STRUCT *PTXT; /* pointer to a text struct */
 typedef PTXT               *HTXT; /* Handle to a text struct */

 #define ihqelMax 256
 #define RADIX    16

 HWND    hGParent;
 HWND    hGMenu;
 HANDLE  rghqel[ihqelMax];
 int     ihqelHead;
 int     ihqelTail;

 int  iLen;
 char pchFoo[MAXFOOLEN];    /* Buffer */

 char szMessages[10][12];   /* messages */

 HWND hWndMenu[10];
 HWND hSpyWndMenu;  /* this is so we can attach the
                       windows text to the menu bar */

 int  dllgfhFile;   /* handle to the file, if open */

 /******************************************/

 /* Handle to the DLL instance from Libinit.asm */
 extern HANDLE LIBINST;

 /*---------------------------------------------------------------------------
 |
 |   f u n c t i o n   d e f i n i t i o n s
 |
 \*---------------------------------------------------------------------------
 void  FAR PASCAL InitHook( HWND );
 BOOL  FAR PASCAL KillHook();
 DWORD FAR PASCAL MsgHook1( WORD, WORD, LPMSG );
 DWORD FAR PASCAL MsgHook2( WORD, WORD, LPMSG );
 void  FAR PASCAL DebugPaint(HWND, HDC);
 HWND  FAR PASCAL CreateDebugWin(HANDLE, HWND);

 void  FAR PASCAL PassFileToDLL(int);
 void  WriteitToFile( LPSTR , int);
 void  FormatString(void);

 void DebugHScroll (HWND, PTXT, int);
 void DebugVScroll (HWND, PTXT, int);
 void Error (char *);

 char   *WM_MessageText(WORD);
 HANDLE HqelGet();
 void   HqelPut(HANDLE);


 void FAR PASCAL PassFileToDLL(int gfhFile)
 {
    dllgfhFile = gfhFile;
 }


 /* ------------------- Set the HOOKs ---------------- */
 void FAR PASCAL InitHook( hWnd )
 HWND hWnd;
 {

    hSpyChild = hWnd;  /* handle to child window */

    fpxMsgHook1 = MakeProcInstance((FARPROC)MsgHook1,LIBINST);
    fpxMsgHook2 = MakeProcInstance((FARPROC)MsgHook2,LIBINST);

    fpxOldHook1 = SetWindowsHook(WH_GETMESSAGE, fpxMsgHook1);
    fpxOldHook2 = SetWindowsHook(WH_CALLWNDPROC,fpxMsgHook2);

    strcpy(szMessages[0], "INITIATE  ");
    strcpy(szMessages[1], "TERMINATE ");
    strcpy(szMessages[2], "ADVISE    ");
    strcpy(szMessages[3], "UNADVISE  ");
    strcpy(szMessages[4], "ACK       ");
    strcpy(szMessages[5], "DATA      ");
    strcpy(szMessages[6], "REQUEST   ");
    strcpy(szMessages[7], "POKE      ");
    strcpy(szMessages[8], "EXECUTE   ");

 return;
 }

 /* ------------------- Remove the HOOKs ---------------- */
 BOOL FAR PASCAL KillHook()
 {
    BOOL fSuccess;

    fSuccess = UnhookWindowsHook( WH_GETMESSAGE,  fpxMsgHook1 );
    fSuccess = UnhookWindowsHook( WH_CALLWNDPROC, fpxMsgHook2 );

    FreeProcInstance( fpxMsgHook1 );
    FreeProcInstance( fpxMsgHook2 );

    return fSuccess;
 }



 /*---------------------------------------------------------------------------
 |  CreateDebugWin (hParent, lpchName, dwStyle, x, y, dx, dy)
 |
 |   Description:
 |     Creates a window for the depositing of debuging messages.
 |
 |   Arguments:
 |     hWnd   - Window handle of the parent window.
 |     pcName - String to appear in the caption bar of the debuging window
 |     dwStyle- Window style
 |     x,y    - Location of window
 |     dx,dy  - Size of the window
 |
 |   Returns:
 |     A window handle of the debuging window, or NULL if a error occured.
 |
 \*---------------------------------------------------------------------------

 HWND FAR PASCAL CreateDebugWin (hInstance, hParent)
 HANDLE  hInstance;
 HWND    hParent;
 {
     static BOOL bFirst = TRUE;   /* Is this the first call */

     HWND   hWnd;
     PTXT   pTxt;      /* pointer to a debuging window struct */

     TEXTMETRIC tm;    /* Used to find out the size of a char */
     RECT       rRect;
     HDC        hDC;
     int        i;

     if (bFirst) {
         /* Find out the size of a Char in the system font */
         hDC = GetDC(hParent);
         GetTextMetrics (hDC,(LPTEXTMETRIC)&tm);
         Tdy = tm.tmHeight;
         Tdx = tm.tmAveCharWidth;
         ReleaseDC (hParent,hDC);
         SetDebugClass(hInstance);
         hGParent = hParent;
         hGMenu = GetMenu(hParent);
         hSpyWndMenu = GetSubMenu( hGMenu ,4 );

         for (i=0 ; i<10 ; i++)         /* clear menu handles */
            hWndMenu[i] = NULL;

         bFirst = FALSE;
     }

     hInstance = GetWindowWord(hParent, GWW_HINSTANCE);
     GetClientRect (hParent,(LPRECT)&rRect);

     hWnd = CreateWindow((LPSTR)"DEBUG"
                         ,(LPSTR)"DDE SPY"
                         ,WS_CHILD | WS_VSCROLL | WS_HSCROLL
                         ,0,0
                         ,rRect.right
                         ,rRect.bottom
                         ,(HWND)hParent      /* parent window */
                         ,(HMENU)NULL        /* use class menu */
                         ,(HANDLE)hInstance  /* handle to window instance */
                         ,(LPSTR)NULL        /* no params to pass on */
                        );

     pTxt = (PTXT)LocalAlloc(LPTR,sizeof(struct TEXT_STRUCT));
     if (!pTxt || !hWnd) {
         Error ("CreateDebugWindow Failed.....");
         return NULL;
     }
     SetWindowWord (hWnd,0,(WORD)pTxt); /* Store the structure pointer with th
                                           window handle */

     pTxt->iFirst = 0;               /* Set the que up to have 1 NULL line */
     pTxt->iCount = 1;
     pTxt->iTop   = 0;
     pTxt->iLeft  = 0;
     pTxt->Text[0]= NULL;
     pTxt->Len[0] = 0;
     pTxt->MaxLen = 0;

     SetScrollRange (hWnd,SB_VERT,0,0,FALSE);
     SetScrollRange (hWnd,SB_HORZ,0,0,FALSE);
     /* Make window visible */
     ShowWindow(hWnd,SHOW_OPENWINDOW);

     return hWnd;
 }


 /*---------------------------------------------------------------------------
 |   SetDebugClass(hInstance)
 |
 |   Description:
 |     Registers a class for a DEBUG window.
 |
 |   Arguments:
 |       hInstance       instance handle of current instance
 |
 |   Returns:
 |       TRUE if successful, FALSE if not
 |
 \*---------------------------------------------------------------------------

 static BOOL SetDebugClass(hInstance)
   HANDLE hInstance;
 {
     WNDCLASS rClass;

     rClass.hCursor        = LoadCursor(NULL,IDC_ARROW);
     rClass.hIcon          = (HICON)NULL;
     rClass.lpszMenuName   = (LPSTR)NULL;
     rClass.lpszClassName  = (LPSTR)"DEBUG";
     rClass.hbrBackground  = (HBRUSH)COLOR_WINDOW + 1;
     rClass.hInstance      = hInstance;
     rClass.style          = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc    = DebugWndProc;
     rClass.cbWndExtra     = sizeof (HANDLE);
     rClass.cbClsExtra     = 0;

     return RegisterClass((LPWNDCLASS)&rClass);
 }



 /*---------------------------------------------------------------------------
 |   MsgHook1 (wToast,pMsg,nCode)
 |
 |   Description:
 |       The Message Hook1 to process all messages...
 |
 |   Arguments:
 |       wToast          integer (0-100) for darkness of toast in morning
 |       pMsg            Pointer to message
 |       nCode           Message context
 |
 |   Returns:
 |       FALSE to let windows process, TRUE to ignore
 |
 \*---------------------------------------------------------------------------
 DWORD FAR PASCAL MsgHook1(code, wToast, lpmsg)
 WORD     code;
 WORD     wToast;
 LPMSG    lpmsg;
 {
    HANDLE hData;
    HANDLE hqel;
    QEL *pqel;
    char rgch[65];

    if (code == HC_ACTION &&
        lpmsg->message >= WM_DDE_FIRST &&
        lpmsg->message <= WM_DDE_LAST)
    {
       hqel=LocalAlloc(LMEM_MOVEABLE|LMEM_ZEROINIT, sizeof(QEL));
       pqel=(QEL *)LocalLock(hqel);
       pqel->msg=*lpmsg;
       switch(lpmsg->message)
       {
       case WM_DDE_TERMINATE:
               break;

       case WM_DDE_ACK:
               if ((unsigned)HIWORD(lpmsg->lParam)>=(unsigned)0xc000)
                       {
                       pqel->un.type=1;
                       goto OneAtom;
                       }
               pqel->un.type=2;
               /* fall thru... */
       case WM_DDE_EXECUTE:
               break;
       case WM_DDE_ADVISE:
               hData=(HANDLE)LOWORD(lpmsg->lParam);
               pqel->un.cf=((DDELN far *)GlobalLock(hData))->cf;
               GlobalUnlock(hData);
               goto OneAtom;
       case WM_DDE_REQUEST:
               pqel->un.cf=LOWORD(lpmsg->lParam);
               goto OneAtom;
       case WM_DDE_DATA:
       case WM_DDE_POKE:
               hData=(HANDLE)LOWORD(lpmsg->lParam);
               pqel->un.cf=((DDEUP far *)GlobalLock(hData))->cf;
               GlobalUnlock(hData);
               /* fall thru... */
       case WM_DDE_UNADVISE:
 OneAtom:
               rgch[GlobalGetAtomName(HIWORD(lpmsg->lParam), rgch, 64)]='\0';
               pqel->atom1=AddAtom(rgch);
               break;
       }
       LocalUnlock(hqel);
       HqelPut(hqel);
       /* alert window that new queue data is available */
       FormatString();
       /* PostMessage(hSpyApp, WM_USER, 0, 0L); */
    }
    /* do default message handling */
    return(DefHookProc(code, wToast, (DWORD)lpmsg, (FARPROC FAR *)&fpxOldHook1
 }

 /* ----------------------------------------------------- */
 DWORD FAR PASCAL MsgHook2(code, wToast, lpmsgr)
 WORD   code;
 WORD   wToast;
 LPMSGR lpmsgr;
 {
    HANDLE hqel;
    QEL *pqel;
    char rgch[65];

    if (code == HC_ACTION &&
        lpmsgr->message >= WM_DDE_FIRST &&
        lpmsgr->message <= WM_DDE_LAST)
    {
        hqel=LocalAlloc(LMEM_MOVEABLE|LMEM_ZEROINIT, sizeof(QEL));
        pqel=(QEL *)LocalLock(hqel);
        pqel->msg.message =lpmsgr->message;
        pqel->msg.wParam  =lpmsgr->wParam;
        pqel->msg.lParam  =lpmsgr->lParam;
        pqel->msg.hwnd    =lpmsgr->hwnd;
        pqel->un.type     =0;
        rgch[GlobalGetAtomName(LOWORD(lpmsgr->lParam), rgch, 64)]='\0';
        pqel->atom1=AddAtom(rgch);
        rgch[GlobalGetAtomName(HIWORD(lpmsgr->lParam), rgch, 64)]='\0';
        pqel->atom2=AddAtom(rgch);
        LocalUnlock(hqel);
        HqelPut(hqel);
        /* alert window that new queue data is available */
        FormatString();
        /* PostMessage(hSpyApp, WM_USER, 0, 0L); */
    }
    /* do default message handling */
    return(DefHookProc(code, wToast, (DWORD)lpmsgr, (FARPROC FAR *)&fpxOldHook
 }

 /* -------------------- FormatString ------------- */
 void  FormatString()
 {

   HANDLE hqel;
   QEL *pqel;
   HMENU hMenu;
   RECT  rRect;
   char rgch[32];
   char rgch2[32];
   int i;

   /*
    *  if the message is greater than WM_USER then it is a message to
    *  be printed in the window
    */

    while ((hqel=HqelGet())!=NULL)
    {
         pqel=(QEL *)LocalLock(hqel);

 #ifdef OLD
         DebugPrintf(hSpyChild,"%-10s %4.4X %4.4X %4.4X,%4.4X ",
                 WM_messageText(pqel->msg.message),
                 pqel->msg.wParam,
                 pqel->msg.hwnd,
                 LOWORD(pqel->msg.lParam),
                 HIWORD(pqel->msg.lParam));
 #else
         lstrcpy( pchFoo, szMessages[(pqel->msg.message)-WM_DDE_FIRST] );
         lstrcat( pchFoo, "  " );
         ultoa ((DWORD)pqel->msg.wParam, szTemp, 16);
         lstrcat( pchFoo, szTemp );
         lstrcat( pchFoo, "  " );
         ultoa ((DWORD)pqel->msg.hwnd, szTemphWnd, 16);
         lstrcat( pchFoo, szTemphWnd );
         if ( strlen(szTemphWnd) < 4)
           lstrcat( pchFoo, " " );
         lstrcat( pchFoo, "  " );
         ultoa ((DWORD)LOWORD(pqel->msg.lParam), szTemp, 16);
         lstrcat( pchFoo, szTemp );
         if ( strlen(szTemp) < 3)
           lstrcat( pchFoo, "  " );
         if ( strlen(szTemp) < 4)
           lstrcat( pchFoo, " " );
         lstrcat( pchFoo, "  " );
         ultoa ((DWORD)HIWORD(pqel->msg.lParam), szTemp, 16);
         lstrcat( pchFoo, szTemp );

         iLen = 0;
         DebugPrintf(hSpyChild, pchFoo, iLen);


 #endif

 #ifdef MENU
         if ( pqel->msg.message == WM_DDE_INITIATE &&
              pqel->msg.hwnd    != NULL )
         {
           for (i=0 ; i<10 ; i++) {
              if (hWndMenu[i] == NULL ) {
                  hWndMenu[i] = pqel->msg.hwnd;
                  GetWindowText ( pqel->msg.hwnd, szTemp,25 );
                  lstrcat ( szTemphWnd, ":" );
                  lstrcat ( szTemphWnd, szTemp );
                  ChangeMenu(hSpyWndMenu, 153, (LPSTR)szTemphWnd,153,
                             i ? MF_APPEND : MF_CHANGE );
                  if (i == 0) {
                    EnableMenuItem(hGMenu, 152, MF_ENABLED );
                    DrawMenuBar(hGParent);
                  }
                  break;
              }
              else {
                if ( hWndMenu[i] == pqel->msg.hwnd )
                  break;
              }
           }
         }
 #endif
         switch(pqel->msg.message)
         {
           case WM_DDE_ACK:
                 switch (pqel->un.type)
                         {
                 case 1:
                         goto OneAtom;
                 case 2:
                         goto Execute;
                         }
                 /* fall thru... */
           case WM_DDE_INITIATE:
                 rgch[GetAtomName(pqel->atom1, (LPSTR)rgch, 32)]='\0';
                 rgch2[GetAtomName(pqel->atom2, (LPSTR)rgch2, 32)]='\0';
 #ifdef OLD
                 DebugPrintf(hSpyChild,"(App:%s, Topic:%s)",rgch, rgch2);
 #else
                 lstrcpy( pchFoo, " (App:"                     );
                 lstrcat( pchFoo,       rgch                  );
                 lstrcat( pchFoo,           ", Topic:"        );
                 lstrcat( pchFoo,                    rgch2    );
                 lstrcat( pchFoo,                         ")" );
                 DebugPrintf(hSpyChild, pchFoo, iLen);
 #endif
                 DeleteAtom(pqel->atom1);
                 DeleteAtom(pqel->atom2);
                 break;
           case WM_DDE_TERMINATE:
                 break;
           case WM_DDE_UNADVISE:
 OneAtom:
                 rgch[GetAtomName(pqel->atom1, (LPSTR)rgch, 32)]='\0';
 #ifdef OLD
                 DebugPrintf(hSpyChild,"(Item:%s)",rgch);
 #else
                 lstrcpy( pchFoo, " (Items:"      );
                 lstrcat( pchFoo,         rgch   );
                 lstrcat( pchFoo,            ")" );
                 DebugPrintf(hSpyChild, pchFoo, iLen);
 #endif
                 DeleteAtom(pqel->atom1);

                 break;
           case WM_DDE_ADVISE:
           case WM_DDE_DATA:
           case WM_DDE_POKE:
           case WM_DDE_REQUEST:
                 rgch[MyGetClipboardFormatName(pqel->un.cf, (LPSTR)rgch, 32)]=
                 rgch2[GetAtomName(pqel->atom1, (LPSTR)rgch2, 32)]='\0';
 #ifdef OLD
                 DebugPrintf(hSpyChild,"(Format:%s, Item:%s)",rgch, rgch2);
 #else
                 lstrcpy( pchFoo, " (Format:"                    );
                 lstrcat( pchFoo,         rgch                  );
                 lstrcat( pchFoo,             ", Items:"        );
                 lstrcat( pchFoo,                      rgch2    );
                 lstrcat( pchFoo,                           ")" );
                 DebugPrintf(hSpyChild, pchFoo, iLen);
 #endif
                 DeleteAtom(pqel->atom1);
                 break;
           case WM_DDE_EXECUTE:
 Execute:
                 break;
         }
 #ifdef OLD
         DebugPrintf(hSpyChild,"\n");
 #else
         lstrcpy( pchFoo, "\n" );
         DebugPrintf(hSpyChild, pchFoo, iLen);
 #endif

         LocalUnlock(hqel);
         LocalFree(hqel);
    }
    /* return(0L); */
 }

 /*---------------------------------------------------------------------------
 |   DebugPrintf (hWnd,str,...)
 |
 |   Description:
 |       Writes data into the window hWnd (hWnd must be created with
 |       CreateDebugWindow ())
 |       follows the normal C printf definition.
 |
 |   Arguments:
 |       hWnd            window handle for the Degubing window
 |       str             printf control string
 |       ...             extra parameters as required by the contol string
 |
 |   NOTE: if hWnd == NULL text will be printed in the window used in the last
 |         call to DebugPrintf.
 \*---------------------------------------------------------------------------

 int  DebugPrintf (hWnd,format,i)
 HWND hWnd;
 char *format;
 int  i;
 {
 #ifdef OLD
   return vDebugPrintf (hWnd,format,&i);
 #else
   return vDebugPrintf (hWnd,format,i);
 #endif
 }

 #ifdef OLD
 int  vDebugPrintf (hWnd,format,pi)
 HWND hWnd;
 char *format;
 int  *pi;
 #else
 int  vDebugPrintf (hWnd,format,pi)
 HWND hWnd;
 char *format;
 int  pi;
 #endif

 {
   static HWND hWndLast = NULL;
   RECT  rect;
   int   iFree;
   int   iRet;
   int   iLine;
   int   cLine;
   int   cScroll;
   PTXT  pTxt;
   MSG   rMsg;
   POINT rPoint;
 /*
   if (!SSEqualToDS()) {
     Error ("WARNING: SS != DS,  Can't printf to window");
     return 0;
   }
  */
   if (hWnd == NULL) hWnd = hWndLast;

   if (hWnd == NULL || !IsWindow (hWnd)) {
      Error ("WARNING: bad window handle,  Can't printf to window");
      return 0;  /* exit if bad window handle */
   }
   pTxt = (PTXT)GetWindowWord (hWnd,0);
   hWndLast = hWnd;
 #ifdef OLD
   iRet = vsprintf(pchFoo,format,pi);
 #endif

   iLine   = pTxt->iCount - pTxt->iTop;
   cLine   = LinesInDebugWindow(hWnd);
   iFree   = pTxt->iTop;
   cScroll = InsertString (pTxt,pchFoo);  /* Insert text in the que */

   /* Scroll the window if Que overflowed */
   if (pTxt->iCount == MAXLINES && pTxt->iTop == 0) {
     iFree = cScroll - iFree;
     pTxt->iTop = -iFree;
     DebugVScroll (hWnd,pTxt,iFree);
   }

   if (iLine == cLine) {                  /* Scroll the window if last line */
      DebugVScroll (hWnd,pTxt,cScroll);   /* is allso last line in window */
      iLine -= cScroll;
   }

   /* Update the scroll bars */
   SetScrollRange (hWnd,SB_VERT,0,pTxt->iCount-2,FALSE);
   SetScrollRange (hWnd,SB_HORZ,0,pTxt->MaxLen,FALSE);
   SetScrollPos   (hWnd,SB_VERT,pTxt->iTop,FALSE);
   SetScrollPos   (hWnd,SB_HORZ,pTxt->iLeft,FALSE);

   /* Now make sure the new text is painted only if visable */
   GetClientRect(hWnd,(LPRECT)&rect);
   rect.top += (iLine-1) * Tdy;
   InvalidateRect (hWnd,(LPRECT)&rect,FALSE);
   UpdateWindow (hWnd);

   return(iRet);       /* return the count of arguments printed */
 }

 /*---------------------------------------------------------------------------
 |
 \*---------------------------------------------------------------------------

 static void NewLine (pTxt)
 PTXT pTxt;
 {
   int iLast = LAST(pTxt);
   int iLine,cLine;

   if (pTxt->iCount == MAXLINES) {
     LocalFree ((HANDLE)pTxt->Text[pTxt->iFirst]);
     INC (pTxt->iFirst);
     if (pTxt->iTop > 0) pTxt->iTop--;
   }
   else {
     pTxt->iCount++;
   }
   iLast = LAST(pTxt);
   pTxt->Text[iLast] = NULL;
   pTxt->Len[iLast]  = 0;
 }

 /*---------------------------------------------------------------------------
 |
 \*---------------------------------------------------------------------------

 static int InsertString (pTxt,str)
   PTXT pTxt;
   char *str;
 {
   static char   buffer[MAXFOOLEN];               /* intermediate buffer */
   int    iBuf;
   int    iLast = LAST(pTxt);
   int    cLine = 0;

   for (iBuf=0; iBuf < pTxt->Len[iLast]; iBuf++)
     buffer[iBuf] = pTxt->Text[iLast][iBuf];

   if (pTxt->Text[iLast] != NULL)
     LocalFree ((HANDLE)pTxt->Text[iLast]);

   while (*str != '\0') {
     while ((*str != '\n') && (*str != '\0'))
       buffer[iBuf++] = *str++;

     /* Test for the case of a zero length line, Only brian would do this */

     if (iBuf == 0)
        pTxt->Text[iLast] == NULL;
     else {
       if ((pTxt->Text[iLast] = (char *)LocalAlloc (LPTR,iBuf)) == NULL)
          Error ("Local alloc failed in Insert string.....");
     }

     pTxt->Len[iLast] = iBuf;
     if (iBuf > pTxt->MaxLen) pTxt->MaxLen = iBuf;
     while (--iBuf >= 0 )
       pTxt->Text[iLast][iBuf] = buffer[iBuf];

     if (*str == '\n') {   /* Now do the next string after the \n */
        str++;
        iBuf = 0;
        cLine++;
        NewLine (pTxt);
        INC(iLast);
     }
   }
   return cLine;
 }


 /*---------------------------------------------------------------------------
 |   DebugWndProc( hWnd, uiMessage, wParam, lParam )
 |
 |   Description:
 |       The window proc for the debuging window.  This processes all
 |       of the window's messages.
 |
 |   Arguments:
 |       hWnd            window handle for the parent window
 |       uiMessage       message number
 |       wParam          message-dependent
 |       lParam          message-dependent
 |
 |   Returns:
 |       0 if processed, nonzero if ignored
 |
 \*---------------------------------------------------------------------------

 long FAR PASCAL DebugWndProc( hWnd, uiMessage, wParam, lParam )
 HWND     hWnd;
 unsigned uiMessage;
 WORD     wParam;
 long     lParam;
 {
     PAINTSTRUCT rPS;
     PTXT        pTxt  = (PTXT)GetWindowWord(hWnd,0);
     RECT        CRect;
     static WORD wScroll;

     switch (uiMessage) {
        /*
         * This tries to go around a BUG in 1.03 about scroll bars being confu
         */
         case WM_SYSCOMMAND:
             switch (wParam & 0xFFF0) {
                 case SC_VSCROLL:
                 case SC_HSCROLL:
                      wScroll = wParam & 0xFFF0;
                 default:
                    return DefWindowProc(hWnd,uiMessage,wParam,lParam);
             }
             break;

         case WM_DESTROY: {
             int i,iQue;

             iQue = TOP(pTxt);
             for (i=0; i < pTxt->iCount; i++,INC(iQue))
               if (pTxt->Text[iQue] != NULL)
                  LocalFree ((HANDLE)pTxt->Text[iQue]);

             LocalFree ((HANDLE)pTxt);
             break;
         }

         case WM_VSCROLL:
             if (wScroll == SC_VSCROLL) {
                switch (wParam) {
                   case SB_LINEDOWN:
                      DebugVScroll (hWnd,pTxt,1);
                      break;
                   case SB_LINEUP:
                      DebugVScroll (hWnd,pTxt,-1);
                      break;
                   case SB_PAGEUP:
                      DebugVScroll (hWnd,pTxt,-PAGE);
                      break;
                   case SB_PAGEDOWN:
                      DebugVScroll (hWnd,pTxt,PAGE);
                      break;
                   case SB_THUMBPOSITION:
                      DebugVScroll (hWnd,pTxt,LOWORD(lParam)-pTxt->iTop);
                      break;
                }
              }
              break;

         case WM_HSCROLL:
             if (wScroll == SC_HSCROLL) {
                switch (wParam) {
                   case SB_LINEDOWN:
                      DebugHScroll (hWnd,pTxt,1);
                      break;
                   case SB_LINEUP:
                      DebugHScroll (hWnd,pTxt,-1);
                      break;
                   case SB_PAGEUP:
                      DebugHScroll (hWnd,pTxt,-PAGE);
                      break;
                   case SB_PAGEDOWN:
                      DebugHScroll (hWnd,pTxt,PAGE);
                      break;
                   case SB_THUMBPOSITION:
                      DebugHScroll (hWnd,pTxt,LOWORD(lParam)-pTxt->iLeft);
                      break;
                }
             }
             break;

         case WM_PAINT:
             BeginPaint(hWnd,(LPPAINTSTRUCT)&rPS);
             DebugPaint (hWnd,rPS.hdc);
             EndPaint(hWnd,(LPPAINTSTRUCT)&rPS);
             break;

         default:
            return DefWindowProc(hWnd,uiMessage,wParam,lParam);
     }
     return 0L;
 }


 /*---------------------------------------------------------------------------
 |   DebugPaint(hWnd, hDC )
 |
 |   Description:
 |       The paint function.
 |
 |   Arguments:
 |       hWnd            Window to paint to.
 |       hDC             handle to update region's display context
 |
 |   Returns:
 |       nothing
 |
 \*---------------------------------------------------------------------------

 void FAR PASCAL DebugPaint(hWnd, hDC)
 HWND hWnd;
 HDC  hDC;
 {
   PTXT pTxt;
   int  i;
   int  iQue;
   int  xco;
   int  yco;
   char iFoo = 0;
   int  iLast;
   int  Wdy;
   RECT CRect;

   pTxt = (PTXT)GetWindowWord(hWnd,0);

   GetClientRect(hWnd,(LPRECT)&CRect);
   Wdy = CRect.bottom-CRect.top;

   iLast = LAST(pTxt);
   iQue  = TOP(pTxt);
   xco   = OFFSETX;
   yco   = OFFSETY;
   for (;;) {
     if (pTxt->Len[iQue] > pTxt->iLeft)
        TextOut (hDC,xco,yco,(LPSTR)pTxt->Text[iQue] + pTxt->iLeft,
                                    pTxt->Len[iQue]  - pTxt->iLeft
                );
     if (iQue == iLast) break;
     INC(iQue);
     yco += Tdy;
     if (yco > Wdy) break;
   }
 }


 /*---------------------------------------------------------------------------
 |
 \*---------------------------------------------------------------------------

 void DebugVScroll (hWnd,pTxt,n)
 HWND hWnd;
 PTXT pTxt;
 int  n;
 {
   int  delta;
   RECT rect;

   GetClientRect (hWnd,(LPRECT)&rect);
   rect.left += OFFSETX;
   rect.top  += OFFSETY;

   if (n > 0) {
      delta = pTxt->iCount - pTxt->iTop - 2;
      if (n > delta) n = delta;
      pTxt->iTop += n;
      ScrollWindow (hWnd,0,-n*Tdy,(LPRECT)&rect,(LPRECT)&rect);
   }
   else {
      n *= -1;
      delta = pTxt->iTop;
      if (n > delta) n = delta;
      pTxt->iTop -= n;
      ScrollWindow (hWnd,0,n*Tdy,(LPRECT)&rect,(LPRECT)&rect);
   }
   SetScrollPos (hWnd,SB_VERT,pTxt->iTop,TRUE);
 }

 /*---------------------------------------------------------------------------
 |
 \*---------------------------------------------------------------------------

 void DebugHScroll (hWnd,pTxt,n)
 HWND hWnd;
 PTXT pTxt;
 int  n;
 {
   int delta;
   RECT rect;

   GetClientRect (hWnd,(LPRECT)&rect);
   rect.left += OFFSETX;
   rect.top  += OFFSETY;

   if (n > 0) {
      delta = pTxt->MaxLen - pTxt->iLeft;
      if (n > delta) n = delta;
      pTxt->iLeft += n;
      ScrollWindow (hWnd,-n*Tdx,0,(LPRECT)&rect,(LPRECT)&rect);
   }
   else {
      n *= -1;
      delta = pTxt->iLeft;
      if (n > delta) n = delta;
      pTxt->iLeft -= n;
      ScrollWindow (hWnd,n*Tdx,0,(LPRECT)&rect,(LPRECT)&rect);
   }
   SetScrollPos (hWnd,SB_HORZ,pTxt->iLeft,TRUE);
 }

 /*---------------------------------------------------------------------------
 |
 \*---------------------------------------------------------------------------

 static
 int LinesInDebugWindow (hWnd)
     HWND hWnd;
 {
     RECT CRect;

     GetClientRect(hWnd,(LPRECT)&CRect);
     return (CRect.bottom-CRect.top) / Tdy + 1;
 }


 /*---------------------------------------------------------------------------
 | Error routine, brings up a message box with a error message
 \*---------------------------------------------------------------------------

 static void Error (str)
 char *str;
 {
   int a = MessageBox (GetFocus(),(LPSTR)str,(LPSTR)NULL,MB_OKCANCEL);
   if (a == IDCANCEL) PostQuitMessage(0);
 }

 /*---------------------------------------------------------------------------
 | routine to verify that SS == DS
 \*---------------------------------------------------------------------------

 static BOOL SSEqualToDS () {
   int a = (int)&a;
   return (int far *)&a == (int far *)(int near *)a;
 }


 int MyGetClipboardFormatName(cf, lpch, cchMac)
 int cf;
 LPSTR lpch;
 int cchMac;
 {
         switch(cf)
                 {
         case CF_TEXT:
                 lstrcpy(lpch,"TEXT");
                 return(4);
         case CF_BITMAP:
                 lstrcpy(lpch,"BITMAP");
                 return(6);
         case CF_METAFILEPICT:
                 lstrcpy(lpch,"METAFILEPICT");
                 return(12);
         case CF_SYLK:
                 lstrcpy(lpch,"SYLK");
                 return(4);
         case CF_DIF:
                 lstrcpy(lpch,"DIF");
                 return(3);
         default:
                 return(GetClipboardFormatName(cf, lpch, cchMac));
                 }
 }


 /* add an element to the queue */
 void HqelPut(hqel)
 HANDLE hqel;
 {

   rghqel[ihqelHead++]=hqel;
   if (ihqelHead==ihqelMax)
     ihqelHead=0;
   if (ihqelHead==ihqelTail)
     MessageBox(GetFocus(), "Queue overflow", NULL, MB_OK|MB_SYSTEMMODAL);
 }

 /* delete an element from the queue */
 HANDLE HqelGet()
 {
   HANDLE hqel;

   if (ihqelTail==ihqelHead)
     return(NULL);
   hqel=rghqel[ihqelTail++];

   if (ihqelTail==ihqelMax)
     ihqelTail=0;

   return(hqel);
 }

 #ifdef OLD
  char *WM_MessageText (uiMsg)
  WORD uiMsg;
  {
    switch (uiMsg)
    {
      case WM_DDE_INITIATE:  return("INITIATE");
      case WM_DDE_TERMINATE: return("TERMINATE");
      case WM_DDE_ADVISE:    return("ADVISE");
      case WM_DDE_UNADVISE:  return("UNADVISE");
      case WM_DDE_ACK:       return("ACK");
      case WM_DDE_DATA:      return("DATA");
      case WM_DDE_REQUEST:   return("REQUEST");
      case WM_DDE_POKE:      return("POKE");
      case WM_DDE_EXECUTE:   return("EXECUTE");
    }
    return(NULL);
  }
 #endif

 #ifdef OLD
  void WriteitToFile( LPSTR lpString, int iLen )
  {
    if (dllgfhFile > 0) {
      _lwrite (dllgfhFile," ",1);
      _lwrite (dllgfhFile,lpString,iLen);
    }
    return;

  }
 #endif



 DUMPER.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFFLIB\DUMPER.C


 #include "stdio.h"


 /*  DUMPER dumps all the records of a specified type  */
 main()
 {
   char filename[12];
   int type;
   int handler(int, char *, int);

   printf("Enter filename\n");
   scanf("%s", filename);
   printf("Enter data type of interest\n");
   scanf("%d", &type);
   open_BIFF(filename);
   read_BIFF(type, handler);
 }

 int handler(int type, char *data, int length)
 {
   int row, column, i;
   unsigned int value;
   double val;
   char *label;

   int get_blank(char *, int *, int *);
   int get_integer(char *, int *, int *, unsigned int *);
   int get_number(char *, int *, int *, double *);
   int get_label(char *, int *, int *,  char **);
   int get_bool(char *, int *, int *, int *);


   switch (type) {
       case 1:
     get_blank(data, &row, &column);
     printf("In row %d column %d is a blank\n", row, column);
     break;
       case 2:
     get_integer(data, &row, &column, &value);
     printf("In row %d column %d is %d\n", row, column, value);
     break;
       case 4:
     get_number(data, &row, &column, &val);
     printf("In row %d column %d is %f\n", row, column, val);
     break;
       case 8:
     get_label(data, &row, &column, &label);
     printf("In row %d column %d is %s\n", row, column, label);
     break;
       case 16:
     get_bool(data, &row, &column, &value);
     printf("In row %d column %d is %d\n", row, column, value);
     break;

   }

 }



 ELLIPSE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\ELLIPSE.C

 /*
  *  Function Name:   Ellipse
  *  Program Name:    ellipse.c
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below will draw an ellipse on the display.
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_Ellipse(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   BOOL      bDrawn;

   bDrawn = Ellipse (hDC, 10, 10, 300, 150);

   if (bDrawn == FALSE)
     MessageBox(hWnd,(LPSTR)"Ellipse failed",(LPSTR)"ERROR",MB_ICONHAND);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Ellipse";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"Ellipse",
                         (LPSTR)"Ellipse()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_Ellipse(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENAWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ENAWIN.C

 /*
  *  Function Name:   EnableWindow
  *  Program Name:    enawin.c
  *
  *  Description:
  *   This function can enable or disable keyboard and mouse input to a
  *   particular window.  The program below will disable input to the
  *   window when it loses the focus. The problem is that then you
  *   can't get the focus back. Oh Well....
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);


 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
     HANDLE hInstance;
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnableWindow";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         return FALSE;

     return TRUE;        /* Initialization succeeded */
     }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
     HANDLE hInstance, hPrevInstance;
     LPSTR lpszCmdLine;
     int cmdShow;
     {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnableWindow",
                         (LPSTR)"EnableWindow()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(hWnd, "This window is disabled when it loses \
 the input focus.", "EnableWindow", MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
     }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
     HWND hWnd;
     unsigned message;
     WORD wParam;
     LONG lParam;
     {
     switch (message)
   {
   /* Disable window if focus is moved to another window */
   case WM_KILLFOCUS:
       EnableWindow(hWnd, FALSE);
       break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return DefWindowProc( hWnd, message, wParam, lParam );
       break;
   }
     return(0L);
     }


 ENAWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\ENAWIN.C

 /*
  *  Function Name:   EnableWindow
  *  Program Name:    enawin.c
  *
  *  Description:
  *   This function can enable or disable keyboard and mouse input to a
  *   particular window.  The program below will disable input to the
  *   window when it loses the focus. The problem is that then you
  *   can't get the focus back. Oh Well....
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);


 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
     HANDLE hInstance;
     {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnableWindow";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         return FALSE;

     return TRUE;        /* Initialization succeeded */
     }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
     HANDLE hInstance, hPrevInstance;
     LPSTR lpszCmdLine;
     int cmdShow;
     {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnableWindow",
                         (LPSTR)"EnableWindow()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(hWnd, "This window is disabled when it loses \
 the input focus.", "EnableWindow", MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
     }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
     HWND hWnd;
     unsigned message;
     WORD wParam;
     LONG lParam;
     {
     switch (message)
   {
   /* Disable window if focus is moved to another window */
   case WM_KILLFOCUS:
       EnableWindow(hWnd, FALSE);
       break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return DefWindowProc( hWnd, message, wParam, lParam );
       break;
   }
     return(0L);
     }


 ENCHWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\ENCHWIN.C

 /*
  *  Function Name:   EnumChildWindows
  *  Program Name:    enchwin.c
  *
  *  Description:
  *   This program will enumerate the child window(s) for the parent
  *   window.  The Class name of the child window will be displayed
  *   in a message box.  This program has only one child window.
  *
  */

 #include "windows.h"
 #include "string.h"
 #include "enchwin.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ChildProc(HWND, unsigned, WORD, LONG);

 char   szAppName [] = "EnChWin" ;
 HWND   hWndChild1, hWndChild2;       /*  child window handle   */
 HANDLE hInst;

 /************************************************************************/

 BOOL FAR PASCAL EnumProc(hChildWindow, lParam)
 HWND   hChildWindow;
 LONG   lParam;
 {
    char szstr[31];

    GetWindowText (hChildWindow, szstr, 30);
    MessageBox(hChildWindow, (LPSTR)szstr,
        (LPSTR)"Name of child window", MB_OK);
    return TRUE;
 }

 /***********************************************************************/

 void CALL_EnumChildWindows(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   FARPROC lpprocEnumChWin;
   char    szstring[80];
   LONG    lParam=0;

     lpprocEnumChWin = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumChildWindows (hWnd, lpprocEnumChWin, lParam);
     FreeProcInstance ((FARPROC) lpprocEnumChWin);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)szAppName;
     wcClass.lpszClassName  = (LPSTR)"EnumChildWindows";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = ChildProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Child";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumChildWindows",
                         (LPSTR)"EnumChildWindows()",
                         WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     hWndChild1 = CreateWindow((LPSTR)"Child",
       (LPSTR)"Child Window 1",
                         WS_CHILD | WS_VISIBLE | WS_CAPTION,
                         50,
       20,
                         120,
       50,
                         (HWND)hWnd,        /* specify hWnd as parent */
                         (HMENU)NULL,       /* use class menu */
       (HANDLE)hInst, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

      hInst = hInstance;    /*  save Instance       */

      hWndChild2 = CreateWindow((LPSTR)"Child",
       (LPSTR)"Child Window 2",
                         WS_CHILD | WS_VISIBLE | WS_CAPTION,
                         50,
       70,
       120,
       50,
                         (HWND)hWnd,        /* specify hWnd as parent */
                         (HMENU)NULL,       /* use class menu */
       (HANDLE)hInst, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

      hInst = hInstance;    /*  save Instance       */


     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_COMMAND:
   switch (wParam)
   {
   case IDM_ENUM:
        ps.hdc = GetDC (hWnd);
        CALL_EnumChildWindows(hWnd, ps.hdc);
        ReleaseDC (hWnd, ps.hdc);
        break ;
   default:
        break ;
   }
     break ;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 long FAR PASCAL ChildProc( hChildWnd, message, wParam, lParam )
 HWND hChildWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;
     switch (message)
     {

     default:
         return DefWindowProc( hChildWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENDDIA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\ENDDIA.C

 /*
  *  Function Name:   EndDialog
  *  Program Name:    enddia.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This function frees resources and reactivates the parent window
  *   while destroying the dialog box.
  */

 #include "windows.h"
 #include "enddia.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE   hInst;

 /**************************************************************************/

 /* Window procedure for the dialog box */
 BOOL FAR PASCAL DialogProc (hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
   if (message == WM_COMMAND)           /* check for WM_COMMAND            */
     EndDialog(hDlg, TRUE);            /* free resources                   */
   else
     return FALSE;
 }

 /**************************************************************************/

 void CALL_EndDialog(hWnd)
 HWND   hWnd;
 {
   FARPROC lpprocDialogBox;
                     /*  Bind calback function with module instance  */
     lpprocDialogBox = MakeProcInstance ((FARPROC) DialogProc, hInst);
                     /*  Create a modal dialog box  */
     DialogBox (hInst, MAKEINTRESOURCE(IDD_10), hWnd, lpprocDialogBox);
     FreeProcInstance ((FARPROC) lpprocDialogBox);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)"MenuName";
     wcClass.lpszClassName  = (LPSTR)"EndDialog";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EndDialog",
                         (LPSTR)"EndDialog()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

      hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }
     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
       case WM_COMMAND:
         switch (wParam)
         {
           case IDM_1:
             CALL_EndDialog(hWnd);
             break;

           default:
             return DefWindowProc( hWnd, message, wParam, lParam );
             break;
         }

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }























 c


 ENDPAINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\ENDPAINT.C

 /*
  *  Function Name:   BeginPaint EndPaint
  *  Program Name:    endpaint.c
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This function tells Windows that the program has finished processing
  *   the paint message and it is okay for Windows to go ahead and remove
  *   the display context.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EndPaint(hDC)
 HDC hDC;
 {
     TextOut(hDC, 10, 10, (LPSTR)"See code for details. /n", 22);

     return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EndPaint";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EndPaint",
                         (LPSTR)"EndPaint()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EndPaint(ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }



 ENFONTS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\ENFONTS.C

 /*
  *  Function Name:   EnumFonts
  *  Program Name:    enfonts.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This program will enumerate one font for each available typeface.
  *   The alphabet of each font will be displayed.
  */

 #include "windows.h"
 #include "stdio.h"
 #include "string.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HWND   hWndMain;            /*  need global handle to window   */
 HANDLE hInst;

 /************************************************************************/

 short FAR PASCAL EnumProc(lpLogFont, lpTextMetric, FontType, lpData)
 LPLOGFONT lpLogFont;
 LPTEXTMETRIC lpTextMetric;
 short FontType;
 LPSTR lpData;
 {
      HFONT hnewFont, holdFont;
      HDC   theDC;
      char  messageStr[256];
      static int row=10;

   theDC = GetDC(hWndMain);
   hnewFont = CreateFontIndirect(lpLogFont);
   holdFont = SelectObject(theDC,hnewFont);       /* load new font  */
   GetTextFace(theDC, 100, (LPSTR)messageStr);
   sprintf (messageStr + strlen(messageStr), " Height: %d Width %d",
            lpLogFont->lfHeight, lpLogFont->lfWidth);
   TextOut(theDC,10,row,(LPSTR) messageStr, strlen(messageStr));
   row += lpLogFont->lfHeight;             /*  advance line   */
   DeleteObject(holdFont);
   ReleaseDC(hWndMain, theDC);

   return (1);                    /* return value is user defined  */
 }

 /***********************************************************************/

 void CALL_EnumFonts(hDC)
 HDC hDC;
 {
   FARPROC lpprocEnumFonts;

     lpprocEnumFonts = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumFonts (hDC, (LPSTR)NULL, lpprocEnumFonts, 0L);
     FreeProcInstance ((FARPROC) lpprocEnumFonts);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumFonts";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumFonts",
                         (LPSTR)"EnumFonts()",
                         WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     hWndMain = hWnd;
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumFonts(ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENHARDIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\ENHARDIN.C

 /*
  *  Function Name:   EnableHardwareInput
  *  Program Name:    enhardin.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This function can disable the mouse and keyboard input.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EnableHardwareInput(hWnd)
 HWND hWnd;
 {
   BOOL      bEnableInput;

   bEnableInput = EnableHardwareInput (TRUE);
                                       /* save input specified, else   */
   if (bEnableInput == TRUE)           /* mouse and keyboard diasbled  */
     MessageBox(hWnd,(LPSTR)"mouse & keyboard enabled",
               (LPSTR)"EnableHardwareInput", MB_OK);
   else
     MessageBox(hWnd,(LPSTR)"mouse & keyboard disabled",
               (LPSTR)"EnableHardwareInput", MB_OK);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnableHardwareInput";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnableHardwareInput",
                         (LPSTR)"EnableHardwareInput()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnableHardwareInput(hWnd);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENHARDIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\ENHARDIN.C

 /*
  *  Function Name:   EnableHardwareInput
  *  Program Name:    enhardin.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   This function can disable the mouse and keyboard input.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EnableHardwareInput(hWnd)
 HWND hWnd;
 {
   BOOL      bEnableInput;

   bEnableInput = EnableHardwareInput (TRUE);
                                       /* save input specified, else   */
   if (bEnableInput == TRUE)           /* mouse and keyboard diasbled  */
     MessageBox(hWnd,(LPSTR)"mouse & keyboard enabled",
               (LPSTR)"EnableHardwareInput", MB_OK);
   else
     MessageBox(hWnd,(LPSTR)"mouse & keyboard disabled",
               (LPSTR)"EnableHardwareInput", MB_OK);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnableHardwareInput";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnableHardwareInput",
                         (LPSTR)"EnableHardwareInput()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnableHardwareInput(hWnd);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENMENUIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\ENMENUIT.C

 /*
  *  Function Name:   EnableMenuItem
  *  Program Name:    enmenuit.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.0
  *
  *  Description:
  *   The program below allows a menu item to be grayed, enabled, or disabled.
  *   The following program will gray a menu item.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EnableMenuItem(hWnd)
 HWND hWnd;
 {
   HMENU hCurrentWindowMenu, hSubItem;
   unsigned wIDNewItem1, wIDNewItem2;
   BOOL  bPrevState;

   hCurrentWindowMenu = CreateMenu();
   hSubItem           = CreateMenu();
                                               /* menu heading created. */
   ChangeMenu (hCurrentWindowMenu, NULL, (LPSTR) "Heading",
               hSubItem, MF_APPEND | MF_BYPOSITION | MF_POPUP);

                                              /* 2 items added under Heading *
   ChangeMenu (hSubItem, NULL, (LPSTR ) "Item1", wIDNewItem1,
                MF_APPEND | MF_BYCOMMAND | MF_STRING);
   ChangeMenu (hSubItem, NULL, (LPSTR) "Item2", wIDNewItem2,
                MF_APPEND | MF_BYCOMMAND | MF_STRING);

   SetMenu(hWnd, hCurrentWindowMenu);

   bPrevState = EnableMenuItem(hCurrentWindowMenu, wIDNewItem1, MF_GRAYED);

 /*  if (bPrevState == 0 or 1 or 2)         0 = ENABLED or error (as in
                                               BYPOSITION invalid number)
                                           1 = GRAYED
                                           2 = DISABLED
   {
     MessageBox(NULL,(LPSTR)"EnableMenuItem failed",(LPSTR)"ERROR",MB_ICONHAND
     return FALSE;
   }
 */

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnableMenuItem";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnableMenuItem",
                         (LPSTR)"EnableMenuItem()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnableMenuItem(hWnd);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENMETAFI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\ENMETAFI.C

 /*
  *  Function Name:   EnumMetaFile
  *  Program Name:    enmetafi.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will create a metafile, close it, then
  *   enumerate it.  The enumeration will play each record in
  *   the metafile.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 /*************************************************************************/

 BOOL FAR PASCAL EnumProc(hDC, lpHTable, lpMFR, nObj, lpClientData)
 HDC      hDC;
 LPHANDLETABLE lpHTable;
 LPMETARECORD  lpMFR;
 int           nObj;
 BYTE FAR *    lpClientData;
 {
   PlayMetaFileRecord(hDC, lpHTable, lpMFR, nObj);
   return(1);
 }

 /***********************************************************************/

 void CALL_EnumMetaFile(hDC)
 HDC hDC;
 {
   FARPROC lpprocEnumMF;
   char szstring[81];
   LOCALHANDLE hMF;
   HDC     hDCMeta;


   hDCMeta = CreateMetaFile((LPSTR) "enmetafi.met");
   Rectangle (hDCMeta, 10, 10, 400, 200);       /*  metafile records    */
   Rectangle (hDCMeta, 20, 20, 300, 180);       /*  for enumeration count  */
   TextOut (hDCMeta, 40, 40, (LPSTR)"Metafile Enumerated", 19);

   hMF = CloseMetaFile (hDCMeta);

     lpprocEnumMF = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumMetaFile(hDC, hMF, lpprocEnumMF, (BYTE FAR *) NULL);
     FreeProcInstance ((FARPROC) lpprocEnumMF);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumMetaFile";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumMetaFile",
                         (LPSTR)"EnumMetaFile()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumMetaFile(ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENOBJ.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\OBJECT\ENOBJ.C

 /*
  *  Function Name:   EnumObjects
  *  Program Name:    enobj.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This function enumerates the pens and brushes available on a
  *   device.  The program below will count the number of pen
  *   enumerations.
  */

 #include "windows.h"
 #include "stdio.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;
 int    nResult;

 /*************************************************************************/

 short FAR PASCAL EnumProc(lpObj, lpData)
 LPLOGPEN lpObj;
 LPSTR lpData;
 {
 /*  nPenStyle = lpObj->lopnStyle;   */
   nResult++;                            /* enumerations counted   */
   return (1);                    /* return value is user defined.   */
 }

 /***********************************************************************/

 void CALL_EnumObjects(hDC)
 HDC hDC;
 {
   FARPROC lpprocEnumObj;
   char    szstring[80];
   int     nLength;

     lpprocEnumObj = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumObjects (hDC, OBJ_PEN, lpprocEnumObj, 0L);
     FreeProcInstance ((FARPROC) lpprocEnumObj);

     nLength = sprintf(szstring, "Pen Enumerations = %d ", nResult);
     TextOut (hDC, 10, 10, szstring, nLength);
     nResult = 0;
     return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumObjects";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumObjects",
                         (LPSTR)"EnumObjects()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumObjects(ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENPROPS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ENPROPS.C

 /*
  *  Function Name:   EnumProps
  *  Program Name:    enprops.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This function will enumerate properties assigned to a window.
  *   The program below will assign two properties to the window
  *   and display them during the enumeration.
  */

 #include "windows.h"
 #include "string.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;
 int    nResult;

 /*************************************************************************/

 int FAR PASCAL EnumProc(hWnd, lpString, hData)
 HWND   hWnd;
 LPSTR  lpString;
 HANDLE hData;
 {
   HDC  hDC;
   static int nInc = 10;

   hDC = GetDC(hWnd);
   TextOut(hDC, 10, nInc+=20, lpString, strlen((PSTR) LOWORD(lpString)));
   ReleaseDC (hWnd, hDC);
   return (1);                    /* return value is user defined.   */
 }

 /***********************************************************************/

 void CALL_EnumProps(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   FARPROC lpprocEnumProp;
   char szstring[80];

   SetProp (hWnd, (LPSTR)"prop1", (HANDLE) NULL);
   SetProp (hWnd, (LPSTR)"prop2", (HANDLE) NULL);

     lpprocEnumProp = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumProps (hWnd, lpprocEnumProp);       /*  function demonstrated   */
     FreeProcInstance ((FARPROC) lpprocEnumProp);

   RemoveProp(hWnd, (LPSTR)"prop1");
   RemoveProp(hWnd, (LPSTR)"prop2");

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumProps";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumProps",
                         (LPSTR)"EnumProps()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumProps(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENTAWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ENTAWIN.C

 /*
  *  Function Name:   EnumTaskWindows
  *  Program Name:    entawin.c
  *
  *  Special Notes:   The enumeration does not work.  The callback function
  *                   EnumProc is never reached.
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 /*************************************************************************/

 BOOL FAR PASCAL EnumProc(hWnd, lParam)
 HWND      hWnd;
 LONG      lParam;
 {
     MessageBox(hWnd,(LPSTR)"Made it to enumeration",(LPSTR)"",MB_ICONHAND);
     return (1);
 }

 /***********************************************************************/

 void CALL_EnumTaskWindows(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   FARPROC lpprocEnumTaskWin;
   HANDLE  hTask;

   hTask = GetCurrentTask();
   if (hTask == NULL)
     MessageBox(hWnd,(LPSTR)"task = null",(LPSTR)"",MB_ICONHAND);

   lpprocEnumTaskWin = MakeProcInstance ((FARPROC)EnumProc, hInst);
   if (lpprocEnumTaskWin == NULL)
     MessageBox(hWnd,(LPSTR)"lpEnumFunc = null",(LPSTR)"",MB_ICONHAND);

   EnumTaskWindows (hTask, lpprocEnumTaskWin, (LONG) NULL);

   FreeProcInstance (lpprocEnumTaskWin);
   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumTaskWindows";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumTaskWindows",
                         (LPSTR)"EnumTaskWindows()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(hWnd, "The enumeration does not work.  \
 The callback function is never reached.", "EnumTaskWindows", MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumTaskWindows(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ENWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ENWIN.C

 /*
  *  Function Name:   EnumWindows
  *  Program Name:    enwin.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This function will enumerate all the windows on the screen.  The
  *   name of each window enumerated will be displayed.
  */

 #include "windows.h"
 #include "string.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;
 HWND   hWndGlobal;      /*  for TextOut during enumeration  */

 /*************************************************************************/

 BOOL FAR PASCAL EnumProc(hWnd, lParam)
 HWND   hWnd;
 LONG   lParam;
 {
   HDC  hDC;
   char szstr[80];
   static int inc = 10;

   GetClassName(hWnd, (LPSTR)szstr, 80);
   hDC = GetDC(hWndGlobal);
   TextOut(hDC, 10, inc+=15, (LPSTR)szstr, strlen(szstr));
   ReleaseDC(hWndGlobal, hDC);
   return (1);                    /* returning 0 will stop the enumeration */
 }

 /***********************************************************************/

 void CALL_EnumWindows(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   FARPROC lpprocEnumWindow;
   LONG lParam;

     lpprocEnumWindow = MakeProcInstance ((FARPROC) EnumProc, hInst);
     EnumWindows (lpprocEnumWindow, lParam);   /*  function demonstrated   */
     FreeProcInstance ((FARPROC) lpprocEnumWindow);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EnumWindows";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EnumWindows",
                         (LPSTR)"EnumWindows()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );
     hInst = hInstance;
     hWndGlobal = hWnd;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EnumWindows(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 EQRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\EQRECT.C

 /*
  *  Function Name:   EqualRect
  *  Program Name:    eqrect.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This function compares the upper-left and lower-right hand corners
  *   of two rectangles for eqality.  If they are equal, a non-zero
  *   value returns, else a zero returns.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EqualRect(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   BOOL   bEqual;
   static RECT      rRect1 = { 30, 30, 60, 60 };
   static RECT      rRect2 = { 30, 30, 60, 60 };

   Rectangle( hDC, 30, 30, 60, 60 );
                                          /*  function demonstrated   */
   bEqual = EqualRect ((LPRECT) &rRect1, (LPRECT) &rRect2);

   if (bEqual == NULL)
       TextOut(hDC, 10, 10, (LPSTR)"Rectangle coordinates are not equal", 35);
   else
       TextOut(hDC, 10, 10, (LPSTR)"Rectangle coordinates are equal", 31);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EqualRect";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EqualRect",
                         (LPSTR)"EqualRect()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EqualRect(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 EQRGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\EQRGN.C

 /*
  *  Function Name:   EqualRgn
  *  Program Name:    eqrgn.c
  *
  *  Description:
  *   This function will compare the coordinates of two regions.  If
  *   both regions are the same size and in the same place, a nonzero
  *   value will return.  Otherwise a zero is returned.
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EqualRgn(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hRgn1, hRgn2;
   BOOL bEqual;

   MessageBox(hWnd, "Creating two rectangular regions at \
 (30,30)-(90,90)...", "EqualRgn", MB_OK);

   hRgn1 = CreateRectRgn(30, 30, 90, 90);
   hRgn2 = CreateRectRgn(30, 30, 90, 90);
   InvertRgn(hDC, hRgn1);                        /* make region visible  */

   bEqual = EqualRgn(hRgn1, hRgn2);        /* compare regions       */

   if (bEqual)
     TextOut (hDC, 10, 10, (LPSTR)"Regions are equal", 17);
   else
     TextOut (hDC, 10, 10, (LPSTR)"Regions are not equal", 21);

   DeleteObject( hRgn1 );
   DeleteObject( hRgn2 );

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EqualRgn";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EqualRgn",
                         (LPSTR)"EqualRgn()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
   CALL_EqualRgn(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ESC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\ESC.C

 /*
  *  Function Name:   Escape
  *  Program Name:    esc.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will retrieve and display the physical page size
  *   for the installed printer.
  */

 #include "windows.h"
 #include "stdio.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_Escape(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HDC    hDCDevice;
   char   szDevice[81], szstring[80];
   PSTR   spDeviceName, spFileName, spPort, strtok();
   int    PageCnt, Pages, nResult, nLength;
   POINT  ptPageSize;

   GetProfileString ("windows", "device", "", szDevice, 81);
   spDeviceName = strtok (szDevice, ",");
   spFileName   = strtok (NULL, ", ");
   spPort       = strtok (NULL, ", ");
   hDCDevice = CreateDC(spFileName, szDevice, spPort, 0);
                                                /* function demonstrated  */
   nResult = Escape (hDCDevice, GETPHYSPAGESIZE, 0, 0, (LPSTR)&ptPageSize);

   if (nResult < 0)
   {
     MessageBox(hWnd,(LPSTR)"Escape failed",(LPSTR)"ERROR",MB_ICONHAND);
     return;
   }
   nLength = sprintf(szstring, "Physical page size for %s is  x=%d,  y=%d",
                                spDeviceName, ptPageSize.x, ptPageSize.y);
   TextOut (hDC, 10, 10, szstring, nLength);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Escape";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"Escape",
                         (LPSTR)"Escape()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_Escape(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 ESCCOMF.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\ESCCOMF.C

 /*
  *  Function Name:   EscapeCommFunction
  *  Program Name:    esccomf.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will carry out the extended function given
  *   with LPT2.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_EscapeCommFunction(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   int     nCid, nResult;

   nCid = OpenComm ((LPSTR)"LPT2", 20, 20);
                                           /*  function demonstrated  */
   nResult = EscapeCommFunction (nCid, SETXOFF);

   if (nResult != 0)
        MessageBox (hWnd, (LPSTR)"EscapeCommFunction failed",
                   (LPSTR)"ERROR",MB_ICONHAND);
   else
       TextOut(hDC, 10, 10, (LPSTR)"EscapeCommFunction successful", 29);

   CloseComm (nCid);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"EscapeCommFunction";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"EscapeCommFunction",
                         (LPSTR)"EscapeCommFunction()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_EscapeCommFunction(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 EXAMPLE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DLL\EXAMPLE.C

 typedef double far *LPDOUBLE;
 typedef char   far *LPSTR;


 /* ------------------------------ AA */
 int far pascal TestBool(a)
 int a;
 {
    return (!a);
 }

 /* ------------------------------ */
 LPDOUBLE far pascal TestDouble(a)
 double a;
 {
    static double temp;

    temp = a*2.0;
    return (LPDOUBLE)&temp;
 }

 /* ------------------------------ */
 LPSTR far pascal TestChar(s)
 LPSTR s;
 {
      static char buffer[128];
      char *t;

      t = buffer;
      while (*s++) {
           *t++ = '$';
      }
      *t = '\0';
      return (LPSTR) buffer;
 }

 /* ------------------------------ */
 LPSTR far pascal TestByte()
 {
      static char buff[24];

      buff[0] = 9;    /* a contains the # of characters to return */
      buff[1] = 'H';
      buff[2] = 'i';
      buff[3] = ' ';
      buff[4] = 'T';
      buff[5] = 'h';
      buff[6] = 'e';
      buff[7] = 'r';
      buff[8] = 'e';
      buff[9] = '.';

    return (LPSTR) buff;
 }

 /* ------------------------------ */
 double far pascal TestFloatBuff(a)
 double *a;
 {

    *a = 2.0;
    return (double) *a;
 }

 /* ------------------------------ */
 LPSTR far pascal TestZBuff(a)
 LPSTR a;
 {

    a[0] = 'G';
    a[1] = 'r';
    a[2] = 'e';
    a[3] = 'e';
    a[4] = 't';
    a[5] = 'i';
    a[6] = 'n';
    a[7] = 'g';
    a[8] = 's';
    a[9] = '\0';

    return (LPSTR) a;
 }

 /* ------------------------------ */
 LPSTR far pascal TestByteBuff(a)
 LPSTR a;
 {

    a[0] = 8;
    a[1] = 'G';
    a[2] = 'o';
    a[3] = 'o';
    a[4] = 'd';
    a[5] = ' ';
    a[6] = 'd';
    a[7] = 'a';
    a[8] = 'y';

    return (LPSTR) a;
 }

 /* ------------------------------ */
 unsigned int far pascal TestUInt(a)
 unsigned int a;
 {
    return (2*a);
 }

 /* ------------------------------ */
 int far pascal TestInt(a)
 int a;
 {
    return (2*a);
 }

 /* ------------------------------ */
 long far pascal TestLong(a)
 long a;
 {
    return (2*a);
 }



 /* ============================== */

 typedef unsigned short  WORD;
 typedef struct fp {
      WORD rows;
      WORD columns;
      double Array[1];
 } FP;
 typedef struct gp {
      WORD rows;
      WORD columns;
      double Array[6];
 } GP;
 typedef FP far *LPFP;
 typedef GP far *LPGP;


 /* ------------------------------ */
 LPDOUBLE far pascal TestAddK(a)
 LPFP a;
 {
      int i,items;
      static double value;

      value = 0.0;
      items = a->rows * a->columns;
      for (i=0 ; i<items ; i++)
         value += a->Array[i];
      return (LPDOUBLE)&value;
 }

 LPGP far pascal ChangeK(a)
 LPFP a;
 {
      int i,items;
      static GP b;

      items = a->rows * a->columns;
      b.rows = 2; b.columns = 3;
      for (i=0 ; i<items ; i++)
        b.Array[i] = a->Array[i] + 1;
      return (LPGP)&b;
 }



 EXAMPLE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFFLIB\EXAMPLE.C



 main()
 {
   static char *names[6] = { "Yankees\0",
       "Tigers\0",
       "Blue Jays\0",
       "Brewers\0",
       "Red Sox\0",
       "Orioles\0" };

   static int wins[6] = {57, 55, 52, 48, 44, 29};
   static int losses[6] = {18, 20, 23, 27, 31, 46};
   int i;

   create_BIFF("ALEast.xls");
   dimension_BIFF(0, 5, 1, 3);
   for (i = 0; i < 6; i++){
     save_BIFF(8, i, 1, names[i]);
     save_BIFF(2, i, 2, (char *) &wins[i]);
     save_BIFF(2, i, 3, (char *) &losses[i]);
   }
   close_BIFF();
 }



 EXCLIPRE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\EXCLIPRE.C

 /*
  *  Function Name:   ExcludeClipRect
  *  Program Name:    exclipre.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This function will exclude an area from a region that would otherwise be
  *   accessible.  The program below creates a rectangular region, excludes
  *   part of the rectangle, then inverts the region, showing the excluded
  *   rectangle is unaffected by the inversion.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_ExcludeClipRect(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hNewRgn;
   short nRgnType;

   hNewRgn = CreateRectRgn(0, 0, 200, 100);

   nRgnType = ExcludeClipRect(hDC, 50, 20, 100, 50);  /* rectangle clipped   *
                                                       /* from region
   if (nRgnType == 1)                     /* Check for error */
     {
     MessageBox(hWnd,(LPSTR)"SelectClipRgn failed.",(LPSTR)"ERROR",MB_ICONHAND
       return;
     }
   InvertRgn(hDC, hNewRgn);
   DeleteObject( hNewRgn );

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"ExcludeClipRect";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"ExcludeClipRect",
                         (LPSTR)"ExcludeClipRect()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_ExcludeClipRect(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 EXTEXTO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\EXTEXTO.C

 /*
  *  Function Name:   ExtTextOut
  *  Program Name:    extexto.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will display text in the given rectangular region.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_ExtTextOut(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   RECT    rTextRect;
   BOOL    bDrawn;

   rTextRect.left    = 0;
   rTextRect.top     = 0;
   rTextRect.right   = 350;
   rTextRect.bottom  = 25;
                                      /* function demonstrated */
   bDrawn = ExtTextOut (hDC, 10, 10, ETO_CLIPPED, (LPRECT) &rTextRect,
              (LPSTR) "Sample showing ExtTextOut", 25, (LPINT) NULL);

   if (bDrawn == FALSE)
     MessageBox(hWnd, (LPSTR)"ExtTextOut failed", (LPSTR)"ERROR", MB_ICONHAND)
   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );  /* black brush *
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( BLACK_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"ExtTextOut";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"ExtTextOut",
                         (LPSTR)"ExtTextOut()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_ExtTextOut(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 EXUPRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\EXUPRG.C

 /*
  *  Function Name:   ExcludeUpdateRgn
  *  Program Name:    exuprg.c
  *  Special Notes:
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   This program invalidates a rectangular region, then calls the
  *   ExcludeUpdateRgn function to protect the invalidated rectangle from
  *   being overlayed by succeeding regions, in this case an
  *   elliptical region. The display will show that the elliptical region
  *   did not overlay the invalidated rectangular region.

  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_ExcludeUpdateRgn(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hRgn;
   RECT rect;

   rect.left=70;               /* region to invalidate  */
   rect.top =70;
   rect.right =200;
   rect.bottom=100;

   InvalidateRect(hWnd,(LPRECT)&rect,TRUE);

   ExcludeUpdateRgn(hDC, hWnd);          /*  function demonstrated  */

   hRgn = CreateEllipticRgn( 50, 50, 400, 150);    /*  new region created  */
   InvertRgn(hDC, hRgn);                           /* invert region to show */
   DeleteObject(hRgn);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"ExcludeUpdateRgn";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"ExcludeUpdateRgn",
                         (LPSTR)"ExcludeUpdateRgn()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_ExcludeUpdateRgn(hWnd, ps.hdc);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }



 FAEXIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ENDINGS\FAEXIT.C

 /*
  *  Function demonstrated in this program: FatalExit
  *  Compiler version: C 5.1
  *
  *  Description:
  *   This function is typically used for debugging and cannot be
  *   demonstrated in this program.  Only a message box will display
  *   in this program.
  */

 #include "windows.h"


 /* PROTOTYPES */

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 void CALL_FatalExit(HWND hWnd, HDC hDC);
 BOOL WinInit(HANDLE hInstance);

 /***********************************************************************/

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HDC   hDC;

   if (!hPrevInstance)
   {
 /* Call initialization procedure if this is the first instance */
     if (!WinInit( hInstance ))
       return FALSE;
   }

   hWnd = CreateWindow((LPSTR)"FatalExit",
       (LPSTR)"FatalExit()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   GetDC(hWnd);
   CALL_FatalExit(hWnd, hDC);
   ReleaseDC(hWnd, hDC);

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /***********************************************************************/

 /* Procedures which make up the window class. */
 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }


 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit(hInstance)
 HANDLE hInstance;
 {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon(hInstance, NULL);
   wcClass.hCursor        = LoadCursor(NULL, IDC_ARROW);
   wcClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"FatalExit";

   if (!RegisterClass((LPWNDCLASS) & wcClass))
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 /***********************************************************************/

 void CALL_FatalExit(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {

 /*  FatalExit(0);  */        /*      FatalExit function  */

   MessageBox(hWnd, (LPSTR)"FatalExit cannot be demonstrated \
 - debugging Windows not installed.",
       (LPSTR)"FatalExit", MB_OK);
   return;
 }




 FILLRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\FILLRECT.C

 /*
  *  Function (s) demonstrated in this program: FillRect
  *
  *  Description:
  *   This function will fill in a specified area of type RECT with the
  *   designated brush.  The program below fills a red rectangle.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS wcClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon (hInstance, NULL);
     wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     wcClass.lpszMenuName   = NULL;
     wcClass.lpszClassName  = "FILLRECT";

     if (!RegisterClass (&wcClass))
       return FALSE;
     }

   hWnd = CreateWindow ("FILLRECT",
                       "FillRect",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC    hDC;
   HMENU  hMenu;
   HBRUSH hBrush;
   RECT   ShowRect;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Fill", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hDC = GetDC (hWnd);
         hBrush = CreateSolidBrush (RGB (255, 0, 0));
         ShowRect.left   = 50;
         ShowRect.top    = 20;
         ShowRect.right  = 400;
         ShowRect.bottom = 100;
         FillRect (hDC, (LPRECT) & ShowRect, hBrush);
         DeleteObject (hBrush);
         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
       break;
     }
   return (0L);
   }


 FILLRGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\FILLRGN.C

 /*
  *  Function Name:   FillRgn
  *  Program Name:    fillrgn.c
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will create a region and fill it with a
  *   red background.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_FillRgn (hWnd, hDC)
 HWND hWnd;
 HDC hDC;
   {
   HBRUSH    hBrush;
   HRGN      hNewRgn;
   RECT      ClientRect;

   hBrush = CreateSolidBrush (RGB (255, 0, 0));   /* hBrush created (red). */
   GetClientRect (hWnd, (LPRECT) &ClientRect);
   hNewRgn = CreateRectRgn (10, 10, (ClientRect.right / 2),
                           (ClientRect.bottom / 2));
   FillRgn (hDC, hNewRgn, hBrush);                /* region filled */
   DeleteObject (hBrush);
   DeleteObject (hNewRgn);
   return;
   }

 /**************************************************************************/
 BOOL WinInit (hInstance)
 HANDLE hInstance;
   {
   WNDCLASS   wcClass;

   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = WndProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;
   wcClass.hInstance      = hInstance;
   wcClass.hIcon          = LoadIcon (hInstance, NULL);
   wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
   wcClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   wcClass.lpszMenuName   = (LPSTR)NULL;
   wcClass.lpszClassName  = (LPSTR)"FillRgn";

   if (!RegisterClass ( (LPWNDCLASS) & wcClass))
     return FALSE;

   return TRUE;        /* Initialization succeeded */
   }


 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     if (!WinInit (hInstance))
       return FALSE;

   hWnd = CreateWindow ( (LPSTR)"FillRgn",
                       (LPSTR)"FillRgn ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,          /* no parent */
                       (HMENU)NULL,         /* use class menu */
                       (HANDLE)hInstance,   /* handle to window instance */
                       (LPSTR)NULL);        /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }

   return (int)msg.wParam;
   }

 /**************************************************************************/
 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       CALL_FillRgn (hWnd, ps.hdc);
       ValidateRect (hWnd, (LPRECT) NULL);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 FINDER.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFFLIB\FINDER.C

 #include "stdio.h"

 /* This function displays the contents of a specific spreadsheet cell */
 main()
 {

   char filename[12];

   int open_BIFF(), find_BIFF(), close_BIFF();
   int type, row, col;
   int handler(int, char *, int);


   printf("Enter filename\n");
   scanf("%s", filename);
   printf("Enter type\n");
   scanf("%d", &type);
   printf("Enter row\n");
   scanf("%d", &row);
   printf("Enter col\n");
   scanf("%d", &col);

   open_BIFF(filename);
   find_BIFF(type, row, col, handler);
 }

 int handler(int type, char *data, int length)
 {
   int row, column, i;
   unsigned int value;
   double val;
   char *label;

   int get_blank(char *, int *, int *);
   int get_integer(char *, int *, int *, unsigned int *);
   int get_number(char *, int *, int *, double *);
   int get_label(char *, int *, int *,  char **);
   int get_bool(char *, int *, int *, int *);


   switch (type) {
       case 1:
     get_blank(data, &row, &column);
     printf("In row %d column %d is a blank\n", row, column);
     break;
       case 2:
     get_integer(data, &row, &column, &value);
     printf("In row %d column %d is %d\n", row, column, value);
     break;
       case 4:
     get_number(data, &row, &column, &val);
     printf("In row %d column %d is %f\n", row, column, val);
     break;
       case 8:
     get_label(data, &row, &column, &label);
     printf("In row %d column %d is %s\n", row, column, label);
     break;
       case 16:
     get_bool(data, &row, &column, &value);
     printf("In row %d column %d is %d\n", row, column, value);
     break;
   }

 }



 FINDRES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\FINDRES.C

 /*
  *
  *  Function (s) demonstrated in this program: FindResource
  *  Compiler version: C 5.1
  *
  *  Description:
  *     This program demonstrates the use of the function FindResource.
  *     This function determines the location of a resource in the specified
  *     resource file.
  *
  *  Other references: Clock.c
  *
  */

 #include <windows.h>
 #include "findres.h"

 static HANDLE hInst;
 static char  szFileName[] = "FindRes";
 static char  szFuncName[] = "FindResource";

 long FAR PASCAL WindowProc (HANDLE, unsigned, WORD, LONG);
 BOOL FAR PASCAL FunctionDemonstrated (HWND);

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   exit (msg.wParam);
   }

 /***************************************************************************/

 BOOL WindowInit (hInstance, hPrevInstance, cmdShow)
 HANDLE hInstance, hPrevInstance;
 int  cmdShow;
   {
   HWND  hWnd;

   if (!hPrevInstance)
     {
     WNDCLASS rClass;

     rClass.style      = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WindowProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor          = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon            = LoadIcon (hInstance, szFileName);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = szFileName;
     rClass.lpszClassName = szFileName;

     RegisterClass ( (LPWNDCLASS) & rClass);
     }

   hInst = hInstance;

   hWnd = CreateWindow (szFileName, szFuncName,
                       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }

 /***************************************************************************/

 long    FAR PASCAL WindowProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned    iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   HMENU  hMenu;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();     /*  Add a menu item */
       ChangeMenu (hMenu, NULL, (LPSTR)"FindResource", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 100)  /*  Our Menu item  */
         FunctionDemonstrated (hWnd);
       else
         return (DefWindowProc (hWnd, iMessage, wParam, lParam));
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
       break;
     }
   return (0L);
   }

 /***************************************************************************/

 BOOL FAR PASCAL FunctionDemonstrated (hWnd)
 HWND hWnd;
   {
   MessageBox (NULL, "Looking for resource FindRes", szFuncName, MB_OK);
   if (FindResource (hInst, "FindRes", RT_ICON))
     MessageBox (NULL, "Resource found", szFuncName, MB_OK);
   else
     MessageBox (NULL, "Resource not found", szFuncName, MB_OK);
   return (TRUE);
   }


 FINDWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\FINDWIN.C

 /*
  *
  *  FindWindow
  *
  *  findwin.c, charlesl, v2.00, 30-Dec-1987
  *
  *  This program demonstrates the use of FindWindow function.
  *  This function the handle of the window whose class is given
  *  by it's frist parameter and whose window name (caption) is
  *  given by is second parameter.
  *
  *  Microsoft Product Support Services
  *  Windows Version 2.0 function demonstration application
  *  Copyright (c) Microsoft 1987
  *
  */

 /*************************************************************************/
 /*                           INCLUDE FILES                               */
 /*************************************************************************/

 #include <windows.h>

 /*************************************************************************/
 /*                        STRUCTURE DEFINTIONS                           */
 /*************************************************************************/

 typedef struct
 {
    int nDummy;
 }
 SETUPDATA;

 /*************************************************************************/
 /*                         GLOBAL VARIABLES                              */
 /*************************************************************************/

 static SETUPDATA strSetUpData;
 static HANDLE hInst;
 static char szFileName[] = "findwin";
 static char szFuncName[] = "FindWindow";

 /*************************************************************************/
 /*                       FORWARD REFERENCES                              */
 /*************************************************************************/

 long FAR PASCAL WindowProc ( HANDLE , unsigned , WORD , LONG );

 /*************************************************************************/
 /*                         MAIN PROCEDURE                                */
 /*************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow );

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }
   exit(msg.wParam);
 }

 /*************************************************************************/
 /*                      INITIALIZATION                                   */
 /*************************************************************************/

 BOOL WindowInit (hInstance , hPrevInstance , cmdShow)
 HANDLE hInstance, hPrevInstance;
 int cmdShow;
 {
   HWND  hWnd;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.lpfnWndProc   = WindowProc;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;
      rClass.hInstance     = hInstance;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.lpszMenuName  = (LPSTR) NULL;
      rClass.lpszClassName = (LPSTR) szFileName;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }
   else
      GetInstanceData ( hPrevInstance, (PSTR) &strSetUpData,
         sizeof ( SETUPDATA ) );

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) szFileName, (LPSTR) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) NULL,
                       (HANDLE) hInstance, (LPSTR) NULL );

   ShowWindow ( hWnd , cmdShow );
   UpdateWindow (hWnd);

   return TRUE;
 }

 /*************************************************************************/
 /*                 WINDOW PROCEDURE - PROCESS MESSAGES                   */
 /*************************************************************************/

 long FAR PASCAL WindowProc (hWnd , message , wParam , lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         FunctionDemonstrated ( hWnd, (PAINTSTRUCT *)&ps );
         EndPaint ( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage ( 0 );
         break;

     default:
         return ( DefWindowProc ( hWnd , message , wParam , lParam ) );
         break;
     }
   return ( 0L );
 }

 /*************************************************************************/
 /*              FUNCTION DEMONSTRATED HERE - LOOK HERE                   */
 /*************************************************************************/

 FunctionDemonstrated ( hWnd )
 HWND hWnd;
 {
     HWND hFindWnd;

     MessageBox (NULL, (LPSTR)"Searching for Window", (LPSTR)szFuncName,
        MB_OK);

     hFindWnd = FindWindow ( ( LPSTR ) "findwin", ( LPSTR ) "FindWindow" );

     if ( hFindWnd != NULL )
        MessageBox (NULL, (LPSTR)"Window Found", (LPSTR)szFuncName, MB_OK);
     else
        MessageBox (NULL, (LPSTR)"Window not Found", (LPSTR)szFuncName, MB_OK)

     return TRUE;
 }


 FINDWIND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\FINDWIND.C

 /*
  *
  * Function (s) demonstrated in this program: FindWindow
  * Compiler version:  C 5.10
  *
  * Description:  This function returns a handle to the Window whose caption
  *    matches the caption parameter.  If no match is found a NULL handle is
  *         returned.  The program will tell the MS-DOS executive to minimize
  *         itself.
  */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "FindWind.h"

 void ProcessMessage (HWND, int);

 HWND     hWndParent1;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];

 struct   {
   char  *szMessage;
   } Messages [] =   {
   "About\0",
   "     This is a sample application to demonstrate the\n\
 use of the FindWindow Windows function.",

   "Help Message",
   "     This program uses the FindWindow Windows function\n\
 to get a handle to the MS-DOS Executive.  This handle\n\
 is then displayed in a message box.  The MS-DOS\n\
 Executive is then Iconized.  Use the menu to invoke\n\
 this function.",

   };


 /****************************************************************************

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
   {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
   }


 /****************************************************************************

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      nCmdShow;
   {
   static char   szAppName [] = "FindWind";
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG msg;
   short xScreen, yScreen;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   xScreen = GetSystemMetrics (SM_CXSCREEN);
   yScreen = GetSystemMetrics (SM_CYSCREEN);

   hWndParent1 = CreateWindow (szAppName,          /* window class name
                              "FindWindow",        /* window caption
                              WS_OVERLAPPEDWINDOW, /* window style
                              CW_USEDEFAULT,       /* initial x position
                              0,                   /* initial y position
                              CW_USEDEFAULT,       /* initial x size
                              0,                   /* initial y size
                              NULL,                /* parent window handle
                              NULL,                /* window menu handle
                              hInstance,           /* program instance handle
                              NULL);               /* create parameters

   ShowWindow (hWndParent1, nCmdShow);
   UpdateWindow (hWndParent1);

   hInstMain = hInstance;

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 /****************************************************************************
 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND      hWnd;
 unsigned  iMessage;
 WORD      wParam;
 LONG      lParam;
   {
   HMENU       hMenu;
   HWND        hExecutive;
   PAINTSTRUCT ps;
   static int    xClient, yClient;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);

       ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT, MF_APPEND | MF_STRING);
       break;

     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDM_ABOUT:
           ProcessMessage (hWnd, 0);
           break;
         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_FINDWINDOW:
           hExecutive = FindWindow (NULL, "MS-DOS Executive");
           if (!IsIconic (hExecutive))
             ShowWindow (hExecutive, SW_SHOWMINIMIZED);
           break;

         case IDM_HELP:
           ProcessMessage (hWnd, 2);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 FLASHWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\FLASHWIN.C

 /*
  *
  *  Function demonstrated in this program: FlashWindow
  *  Compiler version: C 5.1
  *
  *  This program demonstrates the use of the function FlashWin. This function
  *  "flashes" the given window once. Flashing window means changing the
  *  appearance of its caption bar or icon as if the window were changing form
  *  inactive to active status, or vice versa. (A grey caption bar or unframed
  *  incon changes to a black caption bar or framed icon; a black caption bar
  *  or framed icon changes to a grey caption bar or unframed icon.)
  *
  */

 #include <windows.h>

 LONG FAR PASCAL WindowProc (HANDLE, unsigned, WORD, LONG);

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
   {
   MSG  msg;
   HWND hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS rClass;

     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WindowProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) "flashwin";

     if (!RegisterClass ( ( LPWNDCLASS) &rClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, "Flash!", 100, MF_APPEND);

   hWnd = CreateWindow ( (LPSTR) "flashwin", (LPSTR) "FlashWindow",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) hMenu,
                       (HANDLE) hInstance, (LPSTR) NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG)&msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG)&msg);
     DispatchMessage ( (LPMSG)&msg);
     }
   exit (msg.wParam);
   }

 long FAR PASCAL WindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   static BOOL bInverted = TRUE;  /* To keep track of Active State of Window *

   switch (message)
     {
     case WM_COMMAND:
       if (wParam == 100)
         FlashWindow (hWnd, TRUE);
       else
         return (DefWindowProc (hWnd, message, wParam, lParam));
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }


 FLOODFIL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\FLOODFIL.C

 /*
  *
  *  Functions demonstrated in this program: FloodFill
  *  Compiler version: C 5.1
  *
  *  This program demonstrates the use of FloodFill function.
  *  This function fills an area of the suface with the current
  *  brush. The area is assumed to be bounded by the given
  *  rgbColor. The function begins at the point specified by
  *  the logical coordinates X, Y and continues in all directions
  *  to the color boundary.
  *
  */

 #include <windows.h>

 static HANDLE hInst;
 static char szFileName[] = "floodfil";
 static char szFuncName[] = "FloodFill";

 long FAR PASCAL WindowProc (HANDLE, unsigned, WORD, LONG);

 /**************************************************************************/

 int PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
   {
   MSG  msg;

   WindowInit (hInstance, hPrevInstance, cmdShow);
   while (GetMessage ( (LPMSG)&msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG)&msg);
     DispatchMessage ( (LPMSG)&msg);
     }
   exit (msg.wParam);
   }
 /**************************************************************************/

 BOOL WindowInit (hInstance, hPrevInstance, cmdShow)
 HANDLE hInstance, hPrevInstance;
 int cmdShow;
   {
   HWND  hWnd;

   if (!hPrevInstance)
      {
      WNDCLASS rClass;

      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.lpfnWndProc   = WindowProc;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;
      rClass.hInstance     = hInstance;
      rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
      rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
      rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
      rClass.lpszMenuName  = (LPSTR) NULL;
      rClass.lpszClassName = (LPSTR) szFileName;

      if (!RegisterClass ( ( LPWNDCLASS) &rClass))
        return FALSE;
      }

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) szFileName, (LPSTR) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND) NULL, (HMENU) NULL,
                       (HANDLE) hInstance, (LPSTR) NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }
 /**************************************************************************/

 long FAR PASCAL WindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT)&ps);
       FunctionDemonstrated (hWnd, (PAINTSTRUCT *)&ps);
       EndPaint (hWnd, (LPPAINTSTRUCT)&ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }

 /*************************************************************************/
 /*              FUNCTION DEMONSTRATED HERE - LOOK HERE                   */
 /*************************************************************************/

 FunctionDemonstrated (hWnd, pps)
 HWND hWnd;
 PAINTSTRUCT *pps;
   {
   HDC hDC = pps->hdc;
   HPEN hPen;
   HPEN hMyPen;
   HBRUSH hBrush;
   HBRUSH hMyBrush;
   BOOL bFilled;

 /*  Creating a rectangle to fill */
   hMyPen = CreatePen (0, 1, RGB (0, 0, 255));
   hPen = SelectObject (hDC, hMyPen);
   Rectangle (hDC, 0, 0, 500, 200);
   hMyPen = SelectObject (hDC, hPen);
   DeleteObject (hMyPen);

 /* Getting a brush to do the filling */
   hMyBrush = GetStockObject (GRAY_BRUSH);
   hBrush = SelectObject (hDC, hMyBrush);

   FloodFill (hDC, 52, 48, RGB (0, 0, 255));

   hMyBrush = SelectObject (hDC, hBrush);

   return TRUE;
   }


 FLUSHCOM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\FLUSHCOM.C

 /*
  *
  *  Function demonstrated in this program: FlushComm
  *
  *  This program demonstrates the use of the function FlushComm.
  *  This function flushes all characters from the transmit or recieve
  *  queue of the communication device specified by the first parameter.
  *  The second parameter speifies which queue (transmit or receive) to
  *  be flushed.
  *
  */

 #include <windows.h>

 static char  szAppName[] = "flushcom";
 static char  szFuncName[] = "FlushComm";

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName,
                       szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HMENU hMenu;
   BOOL  bError;
   int  nCid;
   int  nResult;

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Flush Port", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         bError = FALSE;
         nCid = OpenComm ( (LPSTR) "LPT1", 255, 256);

         if ( (nCid & IE_BADID) == IE_BADID)
           {
           MessageBox (hWnd, (LPSTR)"Invalid or unsupported ID.",
               (LPSTR)szFuncName, MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_BAUDRATE) == IE_BAUDRATE)
           {
           MessageBox (hWnd, (LPSTR)"Unsupported baud rate.",
               (LPSTR)szFuncName, MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_BYTESIZE) == IE_BYTESIZE)
           {
           MessageBox (hWnd, (LPSTR)"Invalid byte size.", (LPSTR)szFuncName,
               MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_DEFAULT) == IE_DEFAULT)
           {
           MessageBox (hWnd, (LPSTR)"Error in default parameters.",
               (LPSTR)szFuncName, MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_HARDWARE) == IE_HARDWARE)
           {
           MessageBox (hWnd, (LPSTR)"Hardware not present.", (LPSTR)szFuncName
               MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_MEMORY) == IE_MEMORY)
           {
           MessageBox (hWnd, (LPSTR)"Device not open.", (LPSTR)szFuncName,
               MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_NOPEN) == IE_NOPEN)
           {
           MessageBox (hWnd, (LPSTR)"Device not opened.", (LPSTR)szFuncName,
               MB_OK);
           bError = TRUE;
           }
         if ( (nCid & IE_OPEN) == IE_OPEN)
           {
           MessageBox (hWnd, (LPSTR)"Device already open.", (LPSTR)szFuncName,
               MB_OK);
           bError = TRUE;
           }
         if (!bError)
           {
           MessageBox (hWnd, (LPSTR)"Flushing LPT1", (LPSTR)szFuncName, MB_OK)
           nResult = FlushComm (nCid, 0);
           if (nResult == 0)
             MessageBox (hWnd, (LPSTR)"LPT1 flushed", (LPSTR)szFuncName,
                 MB_OK);
           else
             MessageBox (hWnd, (LPSTR)"LPT1 not flushed", (LPSTR)szFuncName,
                 MB_OK);
           }
         CloseComm (nCid);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, iMessage, wParam, lParam));
     }
   return (0L);
   }


 FRAMEREC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\FRAMEREC.C

 /*
  * Function (s) demonstrated in this program: FrameRect
  * Compiler version: C 5.1
  *
  * Description:
  *    FrameRect draws a border around a specified rectangle using
  *    a specified brush.
  */

 #include "windows.h"

 int     PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
 BOOL FrameRectInit (HANDLE);
 long    FAR PASCAL FrameRectWndProc (HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;           /* current instance             */
 HANDLE hPrevInstance;       /* previous instance            */
 LPSTR lpCmdLine;            /* command line                 */
 int     nCmdShow;               /* show-window type (open/icon) */
   {
   HWND hWnd;              /* window handle                */
   MSG msg;                /* message                      */

   if (!hPrevInstance)     /* Has application been initialized? */
     if (!FrameRectInit (hInstance))
       return (NULL);  /* Exits if unable to initialize     */

   hInst = hInstance;      /* Saves the current instance        */

   hWnd = CreateWindow ("FrameRect",   /* window class            */
                       "FrameRect Sample Application", /* window name
                       WS_OVERLAPPEDWINDOW,           /* window style
                       CW_USEDEFAULT,                 /* x position
                       CW_USEDEFAULT,                 /* y position
                       CW_USEDEFAULT,                 /* width
                       CW_USEDEFAULT,                 /* height
                       NULL,                          /* parent handle
                       NULL,                          /* menu or child ID
                       hInstance,                     /* instance
                       NULL);                         /* additional info

   if (!hWnd)
     return (NULL);

   ShowWindow (hWnd, nCmdShow);        /* Shows the window        */
   UpdateWindow (hWnd);                /* Sends WM_PAINT message  */

   while (GetMessage (&msg, NULL, NULL, NULL))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 /*************************************************************************/

 BOOL FrameRectInit (hInstance)
 HANDLE hInstance;
   {
   HANDLE hMemory;
   PWNDCLASS pWndClass;
   BOOL bSuccess;

   hMemory = LocalAlloc (LPTR, sizeof (WNDCLASS));
   pWndClass = (PWNDCLASS) LocalLock (hMemory);

   pWndClass->style = NULL;
   pWndClass->lpfnWndProc = FrameRectWndProc;
   pWndClass->hInstance = hInstance;
   pWndClass->hIcon = NULL;
   pWndClass->hCursor = LoadCursor (NULL, IDC_ARROW);
   pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH);
   pWndClass->lpszMenuName = (LPSTR) "FrameRectMenu";
   pWndClass->lpszClassName = (LPSTR) "FrameRect";

   bSuccess = RegisterClass (pWndClass);

   LocalUnlock (hMemory);
   LocalFree (hMemory);

   return (bSuccess);
   }


 /**************************************************************************/

 long    FAR PASCAL FrameRectWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   FARPROC lpProcAbout;        /* pointer to the "About" function */
   RECT  rRect;                /* Will hold client rectangle  */
   HANDLE hDC;                 /* Handle to the display context  */
   PAINTSTRUCT ps;             /* Paint Structure  */
   HBRUSH hPaintBrush;         /* Brush to draw border with  */

   switch (message)
     {
     case WM_SIZE:
     case WM_PAINT:
       GetClientRect (hWnd, (LPRECT) & rRect); /*  Structure holding  */
       InvalidateRect (hWnd, (LPRECT) & rRect, TRUE);
         /*  Erase the background  */
       hDC = BeginPaint (hWnd, &ps);   /*  Get the display context  */
         /*  Make a border inside of the window  */
       rRect.right -= 10;
       rRect.left += 10;
       rRect.top += 10;
       rRect.bottom -= 10;
       hPaintBrush = GetStockObject (BLACK_BRUSH);
         /* Get a dark gray brush */
       FrameRect (hDC, (LPRECT) & rRect, hPaintBrush);
         /* Draw the border with a BLACK_BRUSH */
       EndPaint (hWnd, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (NULL);
   }


 FRAMEREC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\FRAMEREC.C

 /*
  * Function (s) demonstrated in this program: FrameRect
  * Compiler version: C 5.1
  *
  * Description:
  *    FrameRect draws a border around a specified rectangle using
  *    a specified brush.
  */

 #include "windows.h"

 int     PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
 BOOL FrameRectInit (HANDLE);
 long    FAR PASCAL FrameRectWndProc (HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;           /* current instance             */
 HANDLE hPrevInstance;       /* previous instance            */
 LPSTR lpCmdLine;            /* command line                 */
 int     nCmdShow;               /* show-window type (open/icon) */
   {
   HWND hWnd;              /* window handle                */
   MSG msg;                /* message                      */

   if (!hPrevInstance)     /* Has application been initialized? */
     if (!FrameRectInit (hInstance))
       return (NULL);  /* Exits if unable to initialize     */

   hInst = hInstance;      /* Saves the current instance        */

   hWnd = CreateWindow ("FrameRect",   /* window class            */
                       "FrameRect Sample Application", /* window name
                       WS_OVERLAPPEDWINDOW,           /* window style
                       CW_USEDEFAULT,                 /* x position
                       CW_USEDEFAULT,                 /* y position
                       CW_USEDEFAULT,                 /* width
                       CW_USEDEFAULT,                 /* height
                       NULL,                          /* parent handle
                       NULL,                          /* menu or child ID
                       hInstance,                     /* instance
                       NULL);                         /* additional info

   if (!hWnd)
     return (NULL);

   ShowWindow (hWnd, nCmdShow);        /* Shows the window        */
   UpdateWindow (hWnd);                /* Sends WM_PAINT message  */

   while (GetMessage (&msg, NULL, NULL, NULL))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 /*************************************************************************/

 BOOL FrameRectInit (hInstance)
 HANDLE hInstance;
   {
   HANDLE hMemory;
   PWNDCLASS pWndClass;
   BOOL bSuccess;

   hMemory = LocalAlloc (LPTR, sizeof (WNDCLASS));
   pWndClass = (PWNDCLASS) LocalLock (hMemory);

   pWndClass->style = NULL;
   pWndClass->lpfnWndProc = FrameRectWndProc;
   pWndClass->hInstance = hInstance;
   pWndClass->hIcon = NULL;
   pWndClass->hCursor = LoadCursor (NULL, IDC_ARROW);
   pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH);
   pWndClass->lpszMenuName = (LPSTR) "FrameRectMenu";
   pWndClass->lpszClassName = (LPSTR) "FrameRect";

   bSuccess = RegisterClass (pWndClass);

   LocalUnlock (hMemory);
   LocalFree (hMemory);

   return (bSuccess);
   }


 /**************************************************************************/

 long    FAR PASCAL FrameRectWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   FARPROC lpProcAbout;        /* pointer to the "About" function */
   RECT  rRect;                /* Will hold client rectangle  */
   HANDLE hDC;                 /* Handle to the display context  */
   PAINTSTRUCT ps;             /* Paint Structure  */
   HBRUSH hPaintBrush;         /* Brush to draw border with  */

   switch (message)
     {
     case WM_SIZE:
     case WM_PAINT:
       GetClientRect (hWnd, (LPRECT) & rRect); /*  Structure holding  */
       InvalidateRect (hWnd, (LPRECT) & rRect, TRUE);
         /*  Erase the background  */
       hDC = BeginPaint (hWnd, &ps);   /*  Get the display context  */
         /*  Make a border inside of the window  */
       rRect.right -= 10;
       rRect.left += 10;
       rRect.top += 10;
       rRect.bottom -= 10;
       hPaintBrush = GetStockObject (BLACK_BRUSH);
         /* Get a dark gray brush */
       FrameRect (hDC, (LPRECT) & rRect, hPaintBrush);
         /* Draw the border with a BLACK_BRUSH */
       EndPaint (hWnd, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (NULL);
   }


 FRAMERGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\FRAMERGN.C

 /*
  *
  *  Function (s) demonstrated in this program: FrameRgn
  *  Compiler version: C 5.1
  *
  *  Description:
  *     This program demonstrates the use of the function FrameRgn.
  *     This function draws a border around the region specified by a
  *     handle to a region, using the brush specified by a hanle to a
  *     brush. The fourth parameter specifies the width of the border
  *     on vertical brush strokes, and the fifth parameter specifies
  *     the height on horizontal strokes.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "framergn";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow ("framergn",            /* window class name       */
                       "FrameRgn",                 /* window caption
                       WS_OVERLAPPEDWINDOW,        /* window style
                       CW_USEDEFAULT,              /* initial x position
                       0,                          /* initial y position
                       CW_USEDEFAULT,              /* initial x size
                       0,                          /* initial y size
                       NULL,                       /* parent window handle
                       NULL,                       /* window menu handle
                       hInstance,                  /* program instance handle
                       NULL);                      /* create parameters

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   HDC    hDC;
   HMENU  hMenu;
   HRGN   hRgn;
   HBRUSH hBrush;

   switch (message)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Frame", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hRgn = CreateRectRgn (1, 1, 200, 100);
         hBrush = CreateSolidBrush ( (DWORD) 0x0000FF);
         hDC = GetDC (hWnd);
         FrameRgn (hDC, hRgn, hBrush, 10, 10);
         DeleteObject (hRgn);
         DeleteObject (hBrush);
         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (0L);
   }


 FRAMERGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\FRAMERGN.C

 /*
  *
  *  Function (s) demonstrated in this program: FrameRgn
  *  Compiler version: C 5.1
  *
  *  Description:
  *     This program demonstrates the use of the function FrameRgn.
  *     This function draws a border around the region specified by a
  *     handle to a region, using the brush specified by a hanle to a
  *     brush. The fourth parameter specifies the width of the border
  *     on vertical brush strokes, and the fifth parameter specifies
  *     the height on horizontal strokes.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = "framergn";

     if (!RegisterClass (&rClass))
       return FALSE;
     }

   hWnd = CreateWindow ("framergn",            /* window class name       */
                       "FrameRgn",                 /* window caption
                       WS_OVERLAPPEDWINDOW,        /* window style
                       CW_USEDEFAULT,              /* initial x position
                       0,                          /* initial y position
                       CW_USEDEFAULT,              /* initial x size
                       0,                          /* initial y size
                       NULL,                       /* parent window handle
                       NULL,                       /* window menu handle
                       hInstance,                  /* program instance handle
                       NULL);                      /* create parameters

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD        wParam;
 LONG        lParam;
   {
   HDC    hDC;
   HMENU  hMenu;
   HRGN   hRgn;
   HBRUSH hBrush;

   switch (message)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Frame", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hRgn = CreateRectRgn (1, 1, 200, 100);
         hBrush = CreateSolidBrush ( (DWORD) 0x0000FF);
         hDC = GetDC (hWnd);
         FrameRgn (hDC, hRgn, hBrush, 10, 10);
         DeleteObject (hRgn);
         DeleteObject (hBrush);
         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (0L);
   }


 FREERES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\FREERES\FREERES.C

 /*
  *
  *   Functions (s) demonstrated in this program: FreeResource
  *   Compiler version: C 5.1
  *
  *   Description:
  *      This program demonstrates the use of the function FreeResource.
  *      FreeResource removes a loaded resource from memory by freeing the
  *      allocated memory occupied by that resource.
  */

 #include "windows.h"
 #include "freeres.h"
 #include "string.h"

 char  szAppName[10];
 static HANDLE hInst;
 static short    xChar, yChar;

 long    FAR PASCAL FreeresWndProc (HWND, unsigned, WORD, LONG);
 void FreeresPaint (HWND hWnd, HDC hDC);
 BOOL FreeresInit (HANDLE hInstance);

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     if (!FreeresInit (hInstance))
       return FALSE;
     }
   else
     {
          /* Copy data from previous instance */
     GetInstanceData (hPrevInstance, (PSTR)szAppName, 10);
     }
   hWnd = CreateWindow (szAppName, "FreeResource",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       NULL, NULL, hInstance, NULL);
   hInst = hInstance;

     /* Make window visible according to the way the app is activated */
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL FreeresWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   PAINTSTRUCT  ps;
   TEXTMETRIC   tm;
   HDC          hDC;

   switch (message)
     {
     case WM_CREATE:
         {
         hDC = GetDC (hWnd);
         GetTextMetrics (hDC, &tm);
         ReleaseDC (hWnd, hDC);
         xChar = tm.tmAveCharWidth;
         yChar = tm.tmHeight + tm.tmExternalLeading;
         break;
         }
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       FreeresPaint (hWnd, ps.hdc);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }

 /* Procedure called when the application is loaded for the first time */
 BOOL FreeresInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS  pFreeresClass;

 /* Load strings from resource */
   LoadString (hInstance, IDSNAME, szAppName, 10);

   pFreeresClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));
   pFreeresClass->hCursor       = LoadCursor (NULL, IDC_ARROW);
   pFreeresClass->hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
   pFreeresClass->lpszMenuName  = NULL;
   pFreeresClass->lpszClassName = szAppName;
   pFreeresClass->hbrBackground = GetStockObject (WHITE_BRUSH);
   pFreeresClass->hInstance     = hInstance;
   pFreeresClass->style         = CS_HREDRAW | CS_VREDRAW;
   pFreeresClass->lpfnWndProc   = FreeresWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pFreeresClass))
     return FALSE;

   LocalFree ( (HANDLE)pFreeresClass);
   return TRUE;
   }

 /***************************************************************************/
 void FreeresPaint (hWnd, hDC)
 HWND hWnd;
 HDC  hDC;
   {
   GLOBALHANDLE hBitmap1Data; /* Handle to global memory containing bitmap */
   HBITMAP hBitmap1Info;
   BOOL nResult;

 /* This section demonstrates the use of FreeResource */

 /* Locate the bitmap in the resource file and identify it with a handle */
   hBitmap1Info = FindResource (hInst, "face1", RT_BITMAP);

 /* Identify the global memory block to receive the bitmap data */
   hBitmap1Data = LoadResource (hInst, hBitmap1Info);

   nResult = FreeResource (hBitmap1Info);         /* Free allocated memory */

   if (!nResult)
     TextOut (hDC, xChar, yChar, "FreeResource did not work", 25);
   else
     TextOut (hDC, xChar, yChar, "FreeResource worked", 19);
   }


 FREERES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\FREERES.C

 /*
  *
  *   Functions (s) demonstrated in this program: FreeResource
  *   Compiler version: C 5.1
  *
  *   Description:
  *      This program demonstrates the use of the function FreeResource.
  *      FreeResource removes a loaded resource from memory by freeing the
  *      allocated memory occupied by that resource.
  */

 #include "windows.h"
 #include "freeres.h"
 #include "string.h"

 char  szAppName[10];
 static HANDLE hInst;
 static short    xChar, yChar;

 long    FAR PASCAL FreeresWndProc (HWND, unsigned, WORD, LONG);
 void FreeresPaint (HWND hWnd, HDC hDC);
 BOOL FreeresInit (HANDLE hInstance);

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;

   if (!hPrevInstance)
     {
     if (!FreeresInit (hInstance))
       return FALSE;
     }
   else
     {
          /* Copy data from previous instance */
     GetInstanceData (hPrevInstance, (PSTR)szAppName, 10);
     }
   hWnd = CreateWindow (szAppName, "FreeResource",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       NULL, NULL, hInstance, NULL);
   hInst = hInstance;

     /* Make window visible according to the way the app is activated */
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL FreeresWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   PAINTSTRUCT  ps;
   TEXTMETRIC   tm;
   HDC          hDC;

   switch (message)
     {
     case WM_CREATE:
         {
         hDC = GetDC (hWnd);
         GetTextMetrics (hDC, &tm);
         ReleaseDC (hWnd, hDC);
         xChar = tm.tmAveCharWidth;
         yChar = tm.tmHeight + tm.tmExternalLeading;
         break;
         }
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       FreeresPaint (hWnd, ps.hdc);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }

 /* Procedure called when the application is loaded for the first time */
 BOOL FreeresInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS  pFreeresClass;

 /* Load strings from resource */
   LoadString (hInstance, IDSNAME, szAppName, 10);

   pFreeresClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));
   pFreeresClass->hCursor       = LoadCursor (NULL, IDC_ARROW);
   pFreeresClass->hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
   pFreeresClass->lpszMenuName  = NULL;
   pFreeresClass->lpszClassName = szAppName;
   pFreeresClass->hbrBackground = GetStockObject (WHITE_BRUSH);
   pFreeresClass->hInstance     = hInstance;
   pFreeresClass->style         = CS_HREDRAW | CS_VREDRAW;
   pFreeresClass->lpfnWndProc   = FreeresWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pFreeresClass))
     return FALSE;

   LocalFree ( (HANDLE)pFreeresClass);
   return TRUE;
   }

 /***************************************************************************/
 void FreeresPaint (hWnd, hDC)
 HWND hWnd;
 HDC  hDC;
   {
   GLOBALHANDLE hBitmap1Data; /* Handle to global memory containing bitmap */
   HBITMAP hBitmap1Info;
   BOOL nResult;

 /* This section demonstrates the use of FreeResource */

 /* Locate the bitmap in the resource file and identify it with a handle */
   hBitmap1Info = FindResource (hInst, "face1", RT_BITMAP);

 /* Identify the global memory block to receive the bitmap data */
   hBitmap1Data = LoadResource (hInst, hBitmap1Info);

   nResult = FreeResource (hBitmap1Info);         /* Free allocated memory */

   if (!nResult)
     TextOut (hDC, xChar, yChar, "FreeResource did not work", 25);
   else
     TextOut (hDC, xChar, yChar, "FreeResource worked", 19);
   }


 FREERES1.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\FREERES\FREERES1.C

 /*
  *
  *   FreeResource
  *   freeres1.c travisd, v1.00, 29-Dec-1987
  *
  *   This program demonstrates the use of the function FreeResource.
  *   FreeResource removes a loaded resource from memory by freeing the
  *   alllocated memory occupied by that resource.
  *
  *   Microsoft Product Support Services
  *   Windows Version 2.0 function demonstration application
  *   Copyright (c) Microsoft 1987
  *
  */

 #include "windows.h"
 #include "freeres1.h"
 #include "string.h"

 char szAppName[10];
 static HANDLE hInst;

 /* Forward-Reference All Functions */

 long FAR PASCAL FreeRes1WndProc(HWND, unsigned, WORD, LONG);

 /* --------------------------------------------------------------------- */

 void FreeRes1Paint(hWnd, hDC )
 HWND hWnd;
 HDC  hDC;

 {
     GLOBALHANDLE hBitmap1Data; /* Handle to global memory containing bitmap *
     HBITMAP hBitmap1Info;
     BOOL nResult;

 /***************************************************************************/
 /* This section demonstrates the use of FreeResource */

    /* Locate the bitmap in the resource file and identify it with a handle */
     hBitmap1Info = FindResource(hInst, "face1", RT_BITMAP);

             /* Identify the global memory block to receive the bitmap data */
     hBitmap1Data = LoadResource(hInst, hBitmap1Info);

     nResult = FreeResource(hBitmap1Info);         /* Free allocated memory */
     if (nResult = FALSE)
        {
        TextOut( hDC, 10, 10, (LPSTR)"FreeResource did not work",
                 strlen("FreeResource did not work") );
        }
     else
        {
        TextOut( hDC, 10, 10, (LPSTR)"FreeResource worked",
                 strlen("FreeResource worked") );
        }

 /* End of the FreeResource demonstration section */
 /***************************************************************************/
 }
 /* End FreeRes1Paint */
 /* --------------------------------------------------------------------- */

 /* Procedure called when the application is loaded for the first time */
 BOOL FreeRes1Init( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pFreeRes1Class;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );

     pFreeRes1Class = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pFreeRes1Class->hCursor       = LoadCursor( NULL, IDC_ARROW );
     pFreeRes1Class->hIcon         = LoadIcon( hInstance, MAKEINTRESOURCE(FREE
     pFreeRes1Class->lpszMenuName  = (LPSTR)NULL;
     pFreeRes1Class->lpszClassName = (LPSTR)szAppName;
     pFreeRes1Class->hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pFreeRes1Class->hInstance     = hInstance;
     pFreeRes1Class->style         = CS_HREDRAW | CS_VREDRAW;
     pFreeRes1Class->lpfnWndProc   = FreeRes1WndProc;

     if (!RegisterClass( (LPWNDCLASS)pFreeRes1Class ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pFreeRes1Class );
     return TRUE;        /* Initialization succeeded */
 }
 /* End FreeRes1Init */
 /* --------------------------------------------------------------------- */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!FreeRes1Init( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         }
     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)"FreeResource",
                         WS_OVERLAPPEDWINDOW | WS_MAXIMIZE,
                         10,              /*  x - ignored for tiled windows */
                         10,              /*  y - ignored for tiled windows */
                         CW_USEDEFAULT,   /* cx - ignored for tiled windows */
                         CW_USEDEFAULT,   /* cy - ignored for tiled windows */
                         (HWND)NULL,      /* no parent */
                         (HMENU)NULL,     /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }
 /* End WinMain */
 /* --------------------------------------------------------------------- */

 /* Procedures which make up the window class. */
 long FAR PASCAL FreeRes1WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         FreeRes1Paint(hWnd, ps.hdc );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 /* End FreeRes1WndProc */
 /* --------------------------------------------------------------------- */


 GARF.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GARF.C

 /*
  *
  *  GetAspectRatioFilter
  *
  *  This program demonstrates the use of the function GetAspectRatioFilter.
  *  This function retrieves the setting for the current aspect-ratio filter.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 static char  szAppName [] = "GARF";
 static char  szFuncName [] = "GetAspectRatioFilter";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance;
 HANDLE    hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   WNDCLASS  rClass;
   HWND      hWnd;
   MSG       msg;

   if (!hPrevInstance)
     {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR)NULL;
     rClass.lpszClassName = szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
     }

 hWnd = CreateWindow (szAppName,          /* window class name       */
                     szFuncName,          /* window caption          */
                     WS_OVERLAPPEDWINDOW, /* window style            */
                     CW_USEDEFAULT,       /* initial x position      */
                     0,                   /* initial y position      */
                     CW_USEDEFAULT,       /* initial x size          */
                     0,                   /* initial y size          */
                     NULL,                /* parent window handle    */
                     NULL,                /* window menu handle      */
                     hInstance,           /* program instance handle */
                     NULL);               /* create parameters       */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC   hDC;
   HMENU hMenu;
   DWORD dwAspectRatio;
   char  szBuffer[80];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Aspect Ratio", 1000, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_COMMAND:
       if (wParam == 1000)
         {
         hDC = GetDC (hWnd);
         SetMapperFlags (hDC, (DWORD)0);
         dwAspectRatio = GetAspectRatioFilter (hDC);
         sprintf (szBuffer, "%s%hu%s%hu\0",
             "Aspect ratio of filter zero is: x = ", HIWORD (dwAspectRatio),
             " y = ", LOWORD (dwAspectRatio));
         MessageBox (GetFocus (), (LPSTR)szBuffer, (LPSTR)szFuncName, MB_OK);

         SetMapperFlags (hDC, (DWORD)1);
         dwAspectRatio = GetAspectRatioFilter (hDC);
         sprintf (szBuffer, "%s%hu%s%hu\0",
             "Aspect ratio of filter one is: x = ", HIWORD (dwAspectRatio),
             " y = ", LOWORD (dwAspectRatio));
         MessageBox (GetFocus (), (LPSTR)szBuffer, (LPSTR)szFuncName, MB_OK);

         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 GBITDIM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GBITDIM.C

 /*
  *
  *  GetBitmapDimension
  *  gbitdim.c
  *
  *  This program demonstrates the use of the function GetBitmapDimension.
  *  This funtion returns the width and height of the bitmap specified by
  *  the parameter.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
   {
   HBITMAP hBitmap;          /* Handle to the loaded bitmap.   */
   DWORD   dwOldDimensions;  /* Old dimensions of the bitmap.  */
   DWORD   dwDimensions;     /* New dimensions of the bitmap.  */
   char    szOutBuf[50];     /* Output buffer for Message Box. */

        /* Load in the bitmap to examine. */
   hBitmap = LoadBitmap (hInstance, "SCOTTIE");
   if (hBitmap == NULL)
     {
     MessageBox (GetFocus (), (LPSTR)"Cannot Find Bitmap SCOTTIE",
                (LPSTR)"LoadBitmap () Error!", MB_OK | MB_ICONEXCLAMATION);
     return 1;
     }

        /* Set the new dimensions of the bitmap and show the old ones. */
   dwOldDimensions = SetBitmapDimension (hBitmap, (short)15, (short)15);
   sprintf (szOutBuf, "The old dimensions were %hu * %hu",
           LOWORD (dwOldDimensions), HIWORD (dwOldDimensions));
   MessageBox (GetFocus (), (LPSTR)szOutBuf,
              (LPSTR)"SetBitmapDimension ()", MB_OK);

        /* Get the new dimensions. */
   MessageBox (GetFocus (), (LPSTR)"Getting new dimensions.",
              "GetBitmapDimension ()", MB_OK);
   dwDimensions = GetBitmapDimension (hBitmap);

        /* And display them (or an error). */
   sprintf (szOutBuf, "New dimensions are %hu * %hu",
           LOWORD (dwDimensions), HIWORD (dwDimensions));
   if (dwDimensions)
     MessageBox (GetFocus (), (LPSTR)szOutBuf,
                (LPSTR)"GetBitmapDimension ()", MB_OK);
   else
     MessageBox (GetFocus (), (LPSTR)"Function failed",
                (LPSTR)"GetBitmapDimension () Error!",
                MB_OK | MB_ICONEXCLAMATION);

   if (!DeleteObject (hBitmap))
     {
     MessageBox (GetFocus (), (LPSTR)"Bitmap Resources Not Deleted!",
                (LPSTR)"DeleteObject () Error!",
                MB_OK | MB_ICONEXCLAMATION);
     return 1;
     }

   return 0;
   }


 GBMB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GBMB.C

 /*
  *
  *  GetBitmapBits
  *  gbmb.c
  *
  *  This program demonstrates the use of the function GetBitmapBits.
  *  This funtion copies the bits of the specified bitmap into the buffer
  *  that is pointed to by the last parameter.  The middle parameter
  *  specifies the number of bytes to be copied to the buffer.
  *
  *  Other references: cffile.c
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   long dwCount;
   HBITMAP hBitmap;
   PBITMAP pBitmap;
   int nBraemar[500];

   hBitmap = LoadBitmap(hInstance, "SCOTTIE");
   pBitmap = (PBITMAP)LocalAlloc(LMEM_MOVEABLE, sizeof(BITMAP));
   dwCount = GetObject(hBitmap, (long)sizeof(BITMAP), (LPSTR) pBitmap);

   MessageBox(NULL, "Get bitmap", "GetBitmapBits", MB_OK);

   if (GetBitmapBits(hBitmap, dwCount, (LPSTR) nBraemar))
      MessageBox(NULL, "Bitmap copied", "GetBitmapBits", MB_OK);
   else
      MessageBox(NULL, "Bitmap did not copy", "GetBitmapBits", MB_OK);


   return 0;
 }


 GBRUORG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GBRUORG.C

 /*
  *
  *  GetBrushOrg
  *  gbruorg.c
  *
  *  This program demonstrates the use of the function GetBrushOrg.
  *  This function retrieves the current brush origin for the given
  *  device context.
  *
  */

 #include "windows.h"

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   DWORD ptOrigin;
   HDC hDC;
   PAINTSTRUCT ps;
   char szbuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "gbruorg";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ("gbruorg", "GetBrushOrg",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
           NULL, NULL,
           hInstance, NULL );

   ShowWindow(hWnd, cmdShow);
   BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
   hDC=ps.hdc;

   MessageBox(NULL, "Getting brush origin", "GetBrushOrg", MB_OK);
   ptOrigin=GetBrushOrg(hDC);
   sprintf(szbuff, "%s%d%s%d\0", "Brush origin is: x= ", HIWORD(ptOrigin),
       " y= ", LOWORD(ptOrigin));

   MessageBox (NULL, szbuff, "GetBrushOrg", MB_OK);
   return 0;
 }


 GCEM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\GCEM.C

 /*
  *
  *  GetCommEventMask
  *
  *  This program demonstrates the use of the function GetCommEventMask.
  *  This function retrieves the value of the current event mask, and then
  *  clears the mask.
  *
  */

 #include <windows.h>

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int nCid;         /* Comm Port ID.     */
   WORD wEvent;      /* Event mask value. */

   /* Open COM1. */
   nCid = OpenComm((LPSTR)"COM1", 50, 50);
   if (nCid < 0)
     {
     MessageBox(GetFocus(), (LPSTR)"OpenComm Failed", (LPSTR)"OpenComm()",
                MB_OK | MB_ICONEXCLAMATION);
     return 1;
     }

   /* Set the event mask to allow for detection of input break events. */
   SetCommEventMask(nCid, EV_BREAK);

   /* Get the event mask and check to see if a break was detected. This
      would normally be put in a WM_TIMER message for use over time in
      a communications setting. */
   MessageBox(GetFocus(), (LPSTR)"Requesting Communications Event Mask",
              (LPSTR)"GetCommEventMask()", MB_OK);
   wEvent = GetCommEventMask(nCid, EV_BREAK);
   if ((wEvent & EV_BREAK) != 0)
      MessageBox(GetFocus(),
                 (LPSTR)"A Break Event was Detected.",
                 (LPSTR)"GetCommEventMask()",
                 MB_OK);
   else
      MessageBox(GetFocus(),
                 (LPSTR)"A Break Event has Not Arrived.",
                 (LPSTR)"GetCommEventMask()",
                 MB_OK);

   /* Cleanup. */
   CloseComm(nCid);
   return 0;
 }


 GCURPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\GCURPOS.C

 /*
  *  GetCursorPos
  *
  *  This program demonstrates the use of the function GetCursorPos.
  *  GetCursorPos retrieves the cursor position in screen coordinates.
  *  This means that even if the cursor is not in the current window,
  *  it's position will be retrieved. GetCursorPos is called from
  *  WinMain () in this application.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 extern int      FAR PASCAL lstrlen (LPSTR);

 static char  szAppName [] = "GCURPOS";
 static char  szFuncName [] = "GetCursorPos";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   HWND      hWnd;
   WNDCLASS  wndclass;
   MSG       msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName,
                       szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       0,
                       CW_USEDEFAULT,
                       0,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC   hDC;
   HMENU hMenu;
   POINT CursorPos;
   char  szBuffer[30];

   switch (iMessage)
     {
     case WM_CREATE:
       hMenu = CreateMenu ();
       ChangeMenu (hMenu, NULL, (LPSTR)"Curse Tracking", 100, MF_APPEND);
       SetMenu (hWnd, hMenu);
       break;

     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == 100)
         {
         hDC = GetDC (hWnd);
         GetCursorPos ( (LPPOINT) & CursorPos);
         sprintf (szBuffer, "Cursor Position: x = %d y = %d", CursorPos.x,
             CursorPos.y);
         TextOut (hDC, 10, 10,  (LPSTR)szBuffer, lstrlen ( (LPSTR)szBuffer));
         ReleaseDC (hWnd, hDC);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 GDBLCLKT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GDBLCLKT.C

 /*
  * GetDoubleClickTime
  * This function returns the Double Click Time of the mouse.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
   {
   WORD wTime;        /* The current double click time for the mouse. */
   char szOutBuf[80]; /* Output buffer for message box.               */

       /* Get and display the current double click time for the mouse. */
   wTime = GetDoubleClickTime ();
   sprintf (szOutBuf, "%s%hu", "Double click time in milliseconds is: ", wTime
   MessageBox (GetFocus (), (LPSTR)szOutBuf, "GetDoubleClickTime ()", MB_OK);

   return 0;
   }


 GDLGITM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\GDLGITM.C

 /*
  *   GetDlgItem
  *
  *   This program demonstrates the use of the GetDlgItem function.
  *
  */

 #include <windows.h>
 #include <stdio.h>
 #include "gdlgitm.h"

 long FAR PASCAL DlgItmWndProc(HWND, unsigned, WORD, LONG);

 HANDLE  hInst;        /* Instance handle for dialog box. */
 FARPROC lpprocDialog; /* Pointer to dialog procedure.    */

 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
     {
     case WM_INITDIALOG:
       SetFocus(GetDlgItem(hDlg, EDIT_CONTROL));
       return FALSE;

     case WM_COMMAND:
       if (wParam == ID_OK)
         {
         char szBuff[80]; /* Output buffer from the edit control. */
         HWND hCtl;       /* Handle to the edit control, Used by  */
                          /* GetDlgItem().                        */

         /* Get the handle to the edit control window. */
         MessageBox(GetFocus(),
                    (LPSTR)"Getting handle to control in dialog box",
                    (LPSTR)"GetDlgItem", MB_OK);
         hCtl = GetDlgItem(hDlg, EDIT_CONTROL);
         if (hCtl == NULL)
           MessageBox(GetFocus(), (LPSTR)"Error In Obatining Handle!",
                      (LPSTR)"GetDlgItem() Error!",
                      MB_OK | MB_ICONEXCLAMATION);
         else
           /* If the handle is good, get and show the edit control text. */
           SendMessage(hCtl, WM_GETTEXT, (WORD)80, (LONG)szBuff);
           MessageBox(GetFocus(), (LPSTR)szBuff,
                      (LPSTR)"Edit Box Contents using GetDlgItem()",
                      MB_OK);
         /* And Quit. */
         EndDialog(hDlg,TRUE);
         return TRUE;
         }
       else return FALSE;

     default:
       return FALSE;
    }
 }

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG       msg;          /* Window messages.           */
   HWND      hWnd;         /* Window handle.             */
   PWNDCLASS pDlgItmClass; /* Pointer to the class data. */

   pDlgItmClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pDlgItmClass->hCursor       = LoadCursor(NULL, IDC_ARROW);
   pDlgItmClass->hIcon         = LoadIcon(hInstance, NULL);
   pDlgItmClass->lpszMenuName  = (LPSTR)"dlgmenu";
   pDlgItmClass->lpszClassName = (LPSTR)"gdlgitm";
   pDlgItmClass->hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pDlgItmClass->hInstance     = hInstance;
   pDlgItmClass->style         = CS_HREDRAW | CS_VREDRAW;
   pDlgItmClass->lpfnWndProc   = DlgItmWndProc;

   if (!RegisterClass((LPWNDCLASS)pDlgItmClass))
     return FALSE;

   LocalFree((HANDLE)pDlgItmClass);

   hWnd = CreateWindow((LPSTR)"gdlgitm", (LPSTR)"GetDlgItem",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT,  CW_USEDEFAULT,
                       (HWND)NULL, (HMENU)NULL, (HANDLE)hInstance,
                       (LPSTR)NULL);
   hInst = hInstance;

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG)&msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }

   return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL DlgItmWndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
     {
     case WM_COMMAND:
       switch (wParam)
         {
         case ID_DLGMENU:
           /* Show the demo dialog box. */
           lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
           DialogBox(hInst, MAKEINTRESOURCE(ITEMBOX), hWnd, lpprocDialog);
           FreeProcInstance((FARPROC)lpprocDialog);
           break;

         default:
           return DefWindowProc(hWnd, message, wParam, lParam);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
 }


 GDLGITMI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\GDLGITMI.C

 /*
  *   GetDlgItemInt
  *
  *   This program demonstrates the use of the GetDlgItemInt function.
  *
  */

 #include "windows.h"
 #include <stdio.h>
 #include "gdlgitmi.h"

 long FAR PASCAL ItemIWndProc(HWND, unsigned, WORD, LONG);

 HANDLE  hInst;        /* Instance handle for dialog box.   */
 FARPROC lpprocDialog; /* Long pointer to dialog procedure. */
 char    szBuff[80];   /* Buffer for edit control text.     */

 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
   int  nNumber;      /* Integer from the edit control. */
   BOOL bTranslated;  /* Translated flag pointer.       */

   switch (message)
     {
     case WM_INITDIALOG:
       SetFocus(GetDlgItem(hDlg, EDIT_CONTROL));
       return FALSE;

     case WM_COMMAND:
       if (wParam == ID_OK)
         {
          /* Get the integer value of text entered. */
         nNumber = (int)GetDlgItemInt(hDlg, EDIT_CONTROL,
                                      (BOOL FAR *)&bTranslated,
                                      TRUE);
         if (bTranslated != FALSE)
           {  /* Display that value in a message box if valid. */
           sprintf(szBuff, "%s%d", "The number from the edit field: ", nNumber
           MessageBox(GetFocus(), (LPSTR)szBuff,
                      (LPSTR)"GetDlgItemInt()", MB_OK);
           }
         else /* Or display an error. */
           MessageBox(GetFocus(),
                      (LPSTR)"Non-numeric character or exceeded max!",
                      (LPSTR)"GetDlgItemInt() Error!",
                      MB_OK | MB_ICONEXCLAMATION);
         /* Quit the dialog box. */
         EndDialog(hDlg, TRUE);
         return TRUE;
         }
       else
         return FALSE;

     default:
       return FALSE;
     }
 }

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG         msg;         /* Messages.               */
   HWND        hWnd;        /* Window handle.          */
   PWNDCLASS   pItemIClass; /* Window class structure. */

   pItemIClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pItemIClass->hIcon          = LoadIcon(hInstance,NULL);
   pItemIClass->lpszMenuName   = (LPSTR)"getintmenu";
   pItemIClass->lpszClassName  = (LPSTR)"gdlgitmi";
   pItemIClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pItemIClass->hInstance      = hInstance;
   pItemIClass->style          = CS_HREDRAW | CS_VREDRAW;
   pItemIClass->lpfnWndProc    = ItemIWndProc;

   if (!RegisterClass((LPWNDCLASS)pItemIClass))
     return FALSE;
   LocalFree((HANDLE)pItemIClass);

   hWnd = CreateWindow((LPSTR)"gdlgitmi", (LPSTR)"GetDlgItemInt",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT,  CW_USEDEFAULT,
                       (HWND)NULL, (HMENU)NULL, (HANDLE)hInstance,
                       (LPSTR)NULL);
   hInst = hInstance;

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG)&msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL ItemIWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
     {
     case WM_COMMAND:
       switch (wParam)
         {
         case ID_INTBOX:
           lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
           DialogBox(hInst, MAKEINTRESOURCE(INTBOX), hWnd, lpprocDialog);
           FreeProcInstance((FARPROC)lpprocDialog);
           break;

         default:
           return DefWindowProc(hWnd, message, wParam, lParam);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
 }



 GDLGITMT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\GDLGITMT.C

 /*
  *   GetDlgItemText
  *
  *   This program demonstrates the use of the GetDlgItemTxt function.
  *   GetDlgItem text retrieves the caption of or the text associated
  *   with a control in a dialog box. GetDlgItemTxt is called from
  *   DialogBoxProc in this application.
  *
  */

 #include "windows.h"
 #include "gdlgitmt.h"

 long FAR PASCAL ItemTWndProc(HWND, unsigned, WORD, LONG);

 HANDLE  hInst;        /* Instance handle.              */
 FARPROC lpprocDialog; /* Dialog procedure pointer.     */

 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
   int  nNumChars;  /* Number of characters entered in the edit field. */
   char szBuff[80]; /* Buffer for edit control text.                   */

   switch (message)
     {
     case WM_INITDIALOG:
       SetFocus(GetDlgItem(hDlg, EDIT_CONTROL));
       return FALSE;

     case WM_COMMAND:
       if (wParam == ID_OK)
         {
         /* Get the text entered in the dialog box control. */
         nNumChars = GetDlgItemText(hDlg, EDIT_CONTROL,
                                    (LPSTR)szBuff, (int)80);
         if (nNumChars == 0) /* If no text, say it. */
           MessageBox(GetFocus(),
                      (LPSTR)"No characters entered in edit field",
                      (LPSTR)"GetDlgItemText()",
                      MB_OK);
         else /* Otherwise, show the text. */
           MessageBox(GetFocus(),(LPSTR)szBuff,
                      (LPSTR)"GetDlgItemText() Obtained:",
                      MB_OK);
         EndDialog(hDlg,TRUE);
         return TRUE;
         }
       else
         return FALSE;

     default:
       return FALSE;
     }
 }

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   MSG       msg;         /* Message structure.      */
   HWND      hWnd;        /* Window handle.          */
   PWNDCLASS pItemTClass; /* Window class structure. */

   pItemTClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

   pItemTClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
   pItemTClass->hIcon          = LoadIcon(hInstance,NULL);
   pItemTClass->lpszMenuName   = (LPSTR)"textmenu";
   pItemTClass->lpszClassName  = (LPSTR)"gdlgitmt";
   pItemTClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   pItemTClass->hInstance      = hInstance;
   pItemTClass->style          = CS_HREDRAW | CS_VREDRAW;
   pItemTClass->lpfnWndProc    = ItemTWndProc;

   if (!RegisterClass((LPWNDCLASS)pItemTClass))
     return FALSE;
   LocalFree((HANDLE)pItemTClass);

   hWnd = CreateWindow((LPSTR)"gdlgitmt",
                       (LPSTR)"GetDlgItemText",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       (HWND)NULL,
                       (HMENU)NULL,
                       (HANDLE)hInstance,
                       (LPSTR)NULL);
   hInst = hInstance;

   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   while (GetMessage((LPMSG)&msg, NULL, 0, 0))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
     }

   return (int)msg.wParam;
 }

 long FAR PASCAL ItemTWndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
     {
     case WM_COMMAND:
       switch (wParam)
         {
         case ID_TEXTBOX:
           lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
           DialogBox(hInst, MAKEINTRESOURCE(TEXTBOX), hWnd, lpprocDialog);
           FreeProcInstance((FARPROC)lpprocDialog);
           break;

         default:
           return DefWindowProc(hWnd, message, wParam, lParam);
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
       break;
     }
   return(0L);
 }


 GETACTW.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETACTW.C

 /*
  * GetActiveWindow
  *
  * This function obtains a handle to the active window.
  *
  */

 #include <windows.h>
 #include "getactw.h"

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
   HWND     hWnd;     /* Window handle.          */
   WNDCLASS wndclass; /* Window class structure. */
   MSG      msg;      /* Message structure.      */

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = ActiveWndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName  = (LPSTR)"getactw";
     wndclass.lpszClassName = (LPSTR)"getactw";

     if (!RegisterClass(&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow ((LPSTR)"getactw",
                        (LPSTR)"GetActiveWindow",
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, NULL,
                        hInstance, NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return (msg.wParam);
 }

 long FAR PASCAL ActiveWndProc(hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   HWND hWndActive; /* Handle to the active window. */

   switch(iMessage)
     {
      case WM_COMMAND:
        switch (wParam)
          {
          int i; /* Loop Counter. */
          case IDM_GETACTIVEW:
            /* Get the active window and flash that handle. */
            hWndActive = GetActiveWindow();
            for (i = 0; i < 5; i++)
              {
              FlashWindow(hWndActive, FALSE);
              MessageBeep(NULL);
              }
            break;

          default:
            return DefWindowProc(hWnd, iMessage, wParam, lParam);
            break;
          }
       break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return DefWindowProc(hWnd, iMessage, wParam, lParam);
     break;
   }
   return (0L);
 }



 GETASYKS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GETASYKS.C

 /*
  * GetAsyncKeyState
  *
  * This function determines whether a key is up or down, and
  * whether the key was pressed after a previous call to the
  * GetAsyncKeyState function.
  *
  */

 #include <windows.h>

 long FAR PASCAL AsyncWndProc(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
   HWND     hWnd;
   WNDCLASS wndclass;
   MSG      msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = AsyncWndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = "getasyks";

     if (!RegisterClass(&wndclass))
          return FALSE;
     }

   hWnd = CreateWindow ((LPSTR)"getasyks",
                        (LPSTR)"GetAsyncKeyState()",
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, NULL,
                        hInstance, NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
     {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
     }

   return (msg.wParam);
 }

 long FAR PASCAL AsyncWndProc(hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
  switch(iMessage)
    {
    int Keydown;
    PAINTSTRUCT ps;
    HDC hDC;

    case WM_CHAR:
      Keydown = GetAsyncKeyState(VK_F12);
      if ((Keydown & 0x8000) == 0x8000)
        MessageBox(hWnd, (LPSTR)"'F12' is down.",
                   (LPSTR)"GetAsyncKeyState()", MB_OK);
      else if ((Keydown & 0x0001) == 0x0001)
        MessageBox(hWnd,
                   (LPSTR)"'F12' pressed since last GetAsyncState() call.",
                   (LPSTR)"GetAsyncKeyState()", MB_OK);
      else
        MessageBox(hWnd,
                   (LPSTR)"'F12' not pressed since last GetAsyncState() call."
                   (LPSTR)"GetAsyncKeyState()", MB_OK);
      break;

   case WM_PAINT:
      hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
      TextOut(hDC, (short)10, (short)10,
              (LPSTR)"Hit space bar while pressing/not pressing 'F12' to test"
              (short)55);
      EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
      break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return DefWindowProc (hWnd, iMessage, wParam, lParam);
     break;
   }
   return (0L);
 }



 GETBITSM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETBITSM.C

 /*

 Function(s) demonstrated in this program: GetStretchBltMode
 Description:   This function retrieves the current stretching mode.  The
    stretching mode defines how information is to be added or removed from
    bitmaps that are stretched or compressed by using the StretchBlt function.

 Additional Comments:  Possible modes are BLACKONWHITE, WHITEONBLACK,
    and COLORONCOLOR with values 1, 2, and 3 respectively.
 */


 #include <windows.h>
 #include "GetBitSM.h"
 #include <string.h>
 #include <stdio.h>

        char      szAppName[] = "GetBitSM";
        HANDLE      hInstMain;
        HWND      hWndMain;
        char      szOutputBuffer1[70];
        char      szOutputBuffer2[500];
        HBITMAP      hBitmapHelp;

 struct { char *szMessage; }
        Messages [] = { "Help Message",
        "     Sample program to illustrate the use of GetStretchBltMode.\n\
        Choose the option to see the current stretch mode." };


 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
      {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
      }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;
     HBITMAP  hBitmapCirc, hBitmapDiam, hBitmapSqua, hBitmapXs, hBitmapTria,
     hBitmapPlus;
     HMENU  hMenu;
     short  xScreen, yScreen;

     if (!hPrevInstance)
   {
   wndclass.style    = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
   wndclass.lpfnWndProc    = WndProc;
   wndclass.cbClsExtra     = 0;
   wndclass.cbWndExtra     = 0;
   wndclass.hInstance      = hInstance;
   wndclass.hIcon    = NULL;
   wndclass.hCursor  = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = szAppName;
   wndclass.lpszClassName  = szAppName;

   if (!RegisterClass (&wndclass) )
       return FALSE;
   }

     xScreen = GetSystemMetrics (SM_CXSCREEN);
     yScreen = GetSystemMetrics (SM_CYSCREEN);

     hWnd = CreateWindow (szAppName, "Help Window",
      WS_OVERLAPPEDWINDOW, xScreen/7, yScreen/58,
      xScreen*3/4, yScreen*49/50, NULL, NULL, hInstance, NULL);

     hInstMain = hInstance;
     hWndMain  = hWnd;

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

     while (GetMessage (&msg, NULL, 0, 0))
         {
         TranslateMessage (&msg);
         DispatchMessage (&msg);
         }

     DeleteObject (hBitmapHelp);
     return msg.wParam;
     }
 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
    HWND      hWnd;
    unsigned  iMessage;
    WORD      wParam;
    LONG      lParam;
    {
    int           Index;
    HANDLE        hDC;
    HDC           hMemoryDC;
    BITMAP        Bitmap;
    short   foo;

    switch (iMessage)
        {
        case WM_SIZE:
       hDC = GetDC(hWnd);
             hMemoryDC = CreateCompatibleDC(hDC);
             hBitmapHelp = LoadBitmap (hInstMain, "BitmapHelp");
             GetObject(hBitmapHelp, 16, (LPSTR) &Bitmap);
             SelectObject(hMemoryDC, hBitmapHelp);
             foo = GetStretchBltMode (hDC);

             SetStretchBltMode(hDC, BLACKONWHITE);
             StretchBlt(hDC, 0, 0, LOWORD (lParam), HIWORD (lParam),
         hMemoryDC, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);

             SetStretchBltMode(hDC, foo);
       DeleteObject (hBitmapHelp);
       DeleteDC(hMemoryDC);
       ReleaseDC(hWnd, hDC);
       break;

        case WM_COMMAND:
             switch (wParam) {
               case IDM_GETMODE:
                    hDC = GetDC(hWnd);
                    hMemoryDC = CreateCompatibleDC(hDC);
                    hBitmapHelp = LoadBitmap (hInstMain, "BitmapHelp");
                    GetObject(hBitmapHelp, 16, (LPSTR) &Bitmap);
                    SelectObject(hMemoryDC, hBitmapHelp);
                    foo = GetStretchBltMode (hDC);

                    sprintf (szOutputBuffer1, "Stretch Mode = %x, BLACKONWHITE
                             foo);
                    MessageBox (hWnd, szOutputBuffer1, "GetStretchBltMode",
                                MB_OK);

                    SetStretchBltMode(hDC, BLACKONWHITE);
                    StretchBlt(hDC, 0, 0, LOWORD (lParam), HIWORD (lParam),
                    hMemoryDC, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY)
                    SetStretchBltMode(hDC, foo);
                    DeleteObject (hBitmapHelp);
                    DeleteDC(hMemoryDC);
                    ReleaseDC(hWnd, hDC);
                    break;

               case IDM_HELP:
                    ProcessMessage (hWnd, 0);
                    break;
            }
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

        default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }

 /****************************************************************************



 GETBKCLR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETBKCLR.C

 /*
  *
  *   This program demonstrates the use of the GetBkColor function. GetBkColor
  *   gets the double word value of the color that goes behind text, etc.
  *   in the given device.
  *
  */

 #include <windows.h>
 #include <stdio.h>

 #define STR_PUR1  "The purpose of this program is too return the RGB value"
 #define STR_PUR2  " that represents the background color. The value is"
 #define STR_PUR3  " represented as (rrr, ggg, bbb)."

 BOOL HelloInit (HANDLE);
 int PASCAL WinMain(HANDLE, HANDLE, LPSTR, int);
 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 char  szVerbage[47] = "The Background color is behind these characters";

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit(hInstance)
 HANDLE hInstance;
 {
     WNDCLASS   rHelloClass;

     rHelloClass.hCursor        = LoadCursor(NULL,IDC_ARROW );
     rHelloClass.hIcon        = NULL;
     rHelloClass.lpszMenuName   = (LPSTR)NULL;
     rHelloClass.lpszClassName   = (LPSTR)"Sample Application";
     rHelloClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     rHelloClass.hInstance      = hInstance;
     rHelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     rHelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass((LPWNDCLASS)&rHelloClass))
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
    char   szPurpose[255];                /* Message box buffers */
     char  szBuff[80];
     HDC   hDC;                          /*   display context   */
     DWORD dwBkColor;            /* return value from GetBkColr */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
                 (LPSTR)"GetBkColor",
                 WS_OVERLAPPEDWINDOW,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     hDC = GetDC(hWnd);

    sprintf(szPurpose,"%s%s%s\0",STR_PUR1,STR_PUR2,STR_PUR3);

     MessageBox(hWnd,(LPSTR)szPurpose,(LPSTR)"GET BACKGROUNDCOLOR",MB_OK);

     TextOut(hDC,5,5,(LPSTR)szVerbage,(short)47);

     dwBkColor = GetBkColor(hDC);  /* Get the background color of the DC */

     sprintf(szBuff,
             "RGB value of the background color: (%hu, %hu, %hu)",
             GetRValue(dwBkColor), GetGValue(dwBkColor),
             GetBValue(dwBkColor));
     MessageBox(hWnd, (LPSTR)szBuff, (LPSTR)"GET BACKGROUND COLOR", MB_OK);

     SetBkColor(hDC,RGB(0x00,0x00,0x00)); /* change the background to black */
     SetTextColor(hDC,RGB(0xff,0xff,0xff));
     TextOut(hDC,5,25,(LPSTR)szVerbage,(short)47);

     dwBkColor = GetBkColor(hDC);  /* Get the background color of the DC */

     sprintf(szBuff,
             "RGB value of the background color: (%hu, %hu, %hu)",
             GetRValue(dwBkColor), GetGValue(dwBkColor),
             GetBValue(dwBkColor));
     MessageBox(hWnd, (LPSTR)szBuff, (LPSTR)"GET BACKGROUND COLOR", MB_OK);

     ReleaseDC(hWnd,hDC);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc(hWnd,message,wParam,lParam);
         break;

     case WM_DESTROY:
         PostQuitMessage(0);
         break;

     case WM_PAINT:
         BeginPaint(hWnd,(LPPAINTSTRUCT)&ps);
         EndPaint(hWnd,(LPPAINTSTRUCT)&ps);
         break;

     default:
         return DefWindowProc(hWnd,message,wParam,lParam );
         break;
     }
     return(0L);
 }


 GETBKMDE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETBKMDE.C

 /*
  *
  *   This program demonstrates the use of the GetBkMode function. GetBkMode
  *   retrieves the background mode of the given device. The background mode
  *   can be either OPAQUE or TRANSPARENT. The mode affects the background
  *   painting behind text, hatched brushes, and certain pens. GetBkMode is
  *   called from WinMain in this application.
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     HDC   hDC;    /*   display context      */
     short nBkMode;  /*   return value from GetBkMode  */
     int   i;    /*   used in for loop      */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"GetBkColor",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     hDC = GetDC(hWnd);

     for (i=0; i<=200; i+=5)
   {          /* draw line so we can see the affect */
    MoveTo(hDC,i,0);     /*      of the background mode      */
    LineTo(hDC,i,200);
   }

     TextOut(hDC,5,25,
       (LPSTR)"This line written with an OPAQUE Backgound mode",
       (short)47);

     nBkMode = GetBkMode(hDC);  /* Get the background mode of the DC */

     if (nBkMode == OPAQUE)
   MessageBox(hWnd,
        (LPSTR)"is OPAQUE",
        (LPSTR)"GetBkMode says the background mode...",
        MB_OK);
     else if(nBkMode == TRANSPARENT)
   MessageBox(hWnd,
        (LPSTR)"is TRANSPARENT",
        (LPSTR)"GetBkMode says the background mode...",
        MB_OK);
     else
   MessageBox(hWnd,
        (LPSTR)"ERROR",
        (LPSTR)"ERROR",
        MB_OK);


     SetBkMode(hDC,TRANSPARENT);  /* make background mode TRANSPARENT */


     TextOut(hDC,5,55,
       (LPSTR)"This line written with a TRANSPARENT Backgound mode",
       (short)51);

     nBkMode = GetBkMode(hDC);  /* Get the background mode of the DC */

     if (nBkMode == OPAQUE)
   MessageBox(hWnd,
        (LPSTR)"is OPAQUE",
        (LPSTR)"GetBkMode says the background mode...",
        MB_OK);
     else if(nBkMode == TRANSPARENT)
   MessageBox(hWnd,
        (LPSTR)"is TRANSPARENT",
        (LPSTR)"GetBkMode says the background mode...",
        MB_OK);
     else
   MessageBox(hWnd,
        (LPSTR)"ERROR",
        (LPSTR)"ERROR",
        MB_OK);

     ReleaseDC(hWnd,hDC);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETCAP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GETCAP.C

 /*
  *
  *  GetCapture
  *
  *  This program demonstrates the use of the function GetCapture.
  *  This function retrieves a handle that identifies the window that
  *  has the mouse capture.
  *
  */

 #include "windows.h"

 static HWND hWnd;
 char szBuff [70];

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HWND hWndPrev;
   HWND hWndGetCap;
   int  i;

   if (!hPrevInstance)
     {
     WNDCLASS rClass;

     rClass.lpszClassName = (LPSTR)"getcap";
     rClass.hInstance     = hInstance;
     rClass.lpfnWndProc   = DefWindowProc;
     rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon(hInstance, IDI_APPLICATION);
     rClass.lpszMenuName  = (LPSTR)NULL;
     rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;

     RegisterClass((LPWNDCLASS)&rClass);
     }

   hWnd = CreateWindow((LPSTR)"getcap", (LPSTR)"GetCapture",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND)NULL, (HMENU)NULL,
                       (HANDLE)hInstance, (LPSTR)NULL);

   ShowWindow(hWnd, cmdShow);

   MessageBox(GetFocus(), (LPSTR)"Getting window with mouse capture.",
              (LPSTR)"GetCapture()",
               MB_OK);
   SetCapture(hWnd);
   hWndGetCap = GetCapture();

   for (i = 0; i < 5; i++)
     {
     MessageBeep(NULL);
     FlashWindow(hWndGetCap, NULL);
     }

   MessageBox(GetFocus(), (LPSTR)"The capture window has been flashed.",
              (LPSTR)"GetCapture()",
              MB_OK);
   ReleaseCapture();
   return 0;
 }


 GETCAP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GETCAP.C

 /*
  *
  *  GetCapture
  *
  *  This program demonstrates the use of the function GetCapture.
  *  This function retrieves a handle that identifies the window that
  *  has the mouse capture.
  *
  */

 #include "windows.h"

 static HWND hWnd;
 char szBuff [70];

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HWND hWndPrev;
   HWND hWndGetCap;
   int  i;

   if (!hPrevInstance)
     {
     WNDCLASS rClass;

     rClass.lpszClassName = (LPSTR)"getcap";
     rClass.hInstance     = hInstance;
     rClass.lpfnWndProc   = DefWindowProc;
     rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon(hInstance, IDI_APPLICATION);
     rClass.lpszMenuName  = (LPSTR)NULL;
     rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;

     RegisterClass((LPWNDCLASS)&rClass);
     }

   hWnd = CreateWindow((LPSTR)"getcap", (LPSTR)"GetCapture",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND)NULL, (HMENU)NULL,
                       (HANDLE)hInstance, (LPSTR)NULL);

   ShowWindow(hWnd, cmdShow);

   MessageBox(GetFocus(), (LPSTR)"Getting window with mouse capture.",
              (LPSTR)"GetCapture()",
               MB_OK);
   SetCapture(hWnd);
   hWndGetCap = GetCapture();

   for (i = 0; i < 5; i++)
     {
     MessageBeep(NULL);
     FlashWindow(hWndGetCap, NULL);
     }

   MessageBox(GetFocus(), (LPSTR)"The capture window has been flashed.",
              (LPSTR)"GetCapture()",
              MB_OK);
   ReleaseCapture();
   return 0;
 }


 GETCARBT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\GETCARBT.C

 /*
  *
  *  GetCaretBlinkTime
  *
  *  This program demonstrates the use of the function GetCaretBlinkTime.
  *  GetCaretBlinkTime returns the delay in milliseconds between each blink
  *  of the caret. So a big Blink Time means a slow blink speed. GetCaret-
  *  BlinkTime is called from WinMain in this application.
  *
  */

 #include <stdio.h>
 #include <windows.h>

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon     = LoadIcon (hInstance, (LPSTR)NULL);
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcarbt";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND   hWnd;     /*    Handle to the parent window  */
     WORD   wBlinkDelay;   /* return value from GetCaretBlinkTime */
     char   szBuff[30];   /*    buffer for message box  */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setcarbt",
       (LPSTR)"GetCaretBlinkTime",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* create a caret before showing it */
     CreateCaret (hWnd, NULL, 8, 12);
     SetCaretPos (50,50);
     ShowCaret (hWnd);

 /* get the delay in milliseconds of the caret blink speed */
     wBlinkDelay = (WORD)GetCaretBlinkTime();

     sprintf(szBuff,"%d milliseconds",wBlinkDelay);

     MessageBox(hWnd,(LPSTR)szBuff,
         (LPSTR)"The blink delay is",
         MB_OK);

     MessageBox(hWnd,(LPSTR)"speed the blink up",
         (LPSTR)"I am going to...",
         MB_OK);

     SetCaretBlinkTime (GetCaretBlinkTime()/5);   /* cut the delay down */

 /* get the delay in milliseconds of the caret blink speed */
     wBlinkDelay = (WORD)GetCaretBlinkTime();

     sprintf(szBuff,"%d milliseconds",wBlinkDelay);

     MessageBox(hWnd,(LPSTR)szBuff,
         (LPSTR)"The blink delay is",
         MB_OK);

     return 0;
 }


 GETCERRO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\GETCERRO.C

 /*
  *
  *  GetCommError
  *
  *  This program demonstrates the use of the function GetCommError.
  *  This function fills the status buffer pointed to by the last parameter
  *  with the current status of the communication device specified by the
  *  first parameter.  It also returns the error code that have occurred
  *  since the last GetCommError call.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int nCid;
   short nError;

   nCid = OpenComm ( (LPSTR)"COM1", 50, 50);
   if ( nCid < 0 )
      {
      MessageBox (NULL, (LPSTR)"OpenComm Failed", (LPSTR)"OpenComm",
         MB_OK|MB_ICONEXCLAMATION);
      exit (1);
      }
   WriteComm ( nCid, (LPSTR)"This is a test!!!", 25 );

   MessageBox (NULL, (LPSTR)"Clearing communication port", (LPSTR)"GetCommErro
      MB_OK);

   nError = GetCommError ( nCid, NULL );

   if ( nError == CE_BREAK )
      MessageBox (NULL, (LPSTR)"Hardware detected a brake condition",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_CTSTO )
      MessageBox (NULL, (LPSTR)"Clear-to-send timeout",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_DNS )
      MessageBox (NULL, (LPSTR)"Parallel device is not selected",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_DSRTO )
      MessageBox (NULL, (LPSTR)"Data-set-ready timeout",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_FRAME )
      MessageBox (NULL, (LPSTR)"Hardware detects a framing error",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_IOE )
      MessageBox (NULL, (LPSTR)"I/O error while communicate with parallel devi
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_MODE )
      MessageBox (NULL, (LPSTR)"Requested mode is not supported",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_OOP )
      MessageBox (NULL, (LPSTR)"Parallel device signals its out of paper",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_OVERRUN )
      MessageBox (NULL, (LPSTR)"A character has been overrun and lost",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_PTO )
      MessageBox (NULL, (LPSTR)"Timeout while communicating with parallel devi
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_RLSDTO )
      MessageBox (NULL, (LPSTR)"Recieve-line-signal-detect timeout",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_RXOVER )
      MessageBox (NULL, (LPSTR)"Receive queue overflow",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_RXPARITY )
      MessageBox (NULL, (LPSTR)"Hardware detected a parity error",
         (LPSTR)"GetCommError", MB_OK);
   else
   if ( nError == CE_TXFULL )
      MessageBox (NULL, (LPSTR)"Transmit gueue is full while trying \n to queu
         (LPSTR)"GetCommError", MB_OK);
   else
      MessageBox (NULL, (LPSTR)"No ERROR",
         (LPSTR)"GetCommError", MB_OK|MB_ICONEXCLAMATION);

   CloseComm ( nCid );
   return 0;
 }


 GETCHAND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GETCHAND.C

 /*
  *
  *  GetCodeHandle
  *
  *  This program demonstrates the use of the function GetCodeHandle.
  *  This function determines which code segment contains the funtion
  *  pointed to by the parameter.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>
 char szBuffer [70];

 void FAR PASCAL GetMe ()
 {
    int nTest = 0;

    nTest++;
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HANDLE hCode;

   MessageBox (NULL, (LPSTR)"Finding code segment of GetMe function",
      (LPSTR)"GetCodeHandle", MB_OK);

   hCode = GetCodeHandle ( (FARPROC) GetMe );
   sprintf (szBuffer, "The handle to GetMe's code segment is %x", hCode);
   MessageBox (NULL, (LPSTR)szBuffer, (LPSTR)"GetCodeHandle",
               MB_OK);
   return 0;

 }



 GETCLIPF.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIPBORD\GETCLIPF.C

 /*

 Function(s) demonstrated in this program: GetClipboardFormatName

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns the name of the registered format
    requested.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetClipF.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use of the GetClipboardFormatName Windows function.",

 "Help Message",
 "     This program uses the GetClipboardFormatName\n\
 Windows function to retrieve the name of a format\n\
 which was registered just prior to this function call\n\
 under the name of TMSROMAN.  This name is then\n\
 displayed in a Message Box.  Use the menu to invoke\n\
 this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetClipF" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetClipboardFormatName",   /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  WORD        wFormat;
  int         nCopied;
  char        lpFormatName [40];

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETCLIPFNAME:
                MessageBox (NULL, (LPSTR)"Getting clipboard format name",
                   (LPSTR)"GetClipboardFormatName", MB_OK);

                wFormat = RegisterClipboardFormat ( (LPSTR)"TMSROMAN" );
                nCopied = GetClipboardFormatName ( wFormat, lpFormatName, 20 )

                if ( nCopied != 0 )
                    MessageBox (NULL, (LPSTR)lpFormatName,
                               (LPSTR)"The Format Name Is", MB_OK);
                else
                    MessageBox (NULL, (LPSTR)"Format does not exits",
                               (LPSTR)"GetClipboardFormatName", MB_OK);

                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETCLONG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\GETCLONG.C

 /*

 Function(s) demonstrated in this program: GetClassLong

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function retrieves the given LONG value from the
    respective class structure.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetCLong.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetClassLong Windows function.",

 "Help Message",
 "     This program uses the GetClassLong Windows\n\
 function to get a pointer to the menu name of the\n\
 current window.  Use the menu to invoke this\n\
 function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetCLong" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetClassLong",             /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  LONG        lpMenu;
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETCLASSLONG:
                lpMenu = GetClassLong (hWnd, GCL_MENUNAME);
                sprintf (szOutputBuffer1,
                         "The pointer to the menu name is %x", lpMenu);
                MessageBox (hWnd, szOutputBuffer1, "GetClassLong", MB_OK);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETCNAME.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\GETCNAME.C

 /*
  *
  *   GetClassName.c
  *
  *   This program demonstrates the use of the GetClassName function.
  *   Given a handle to a window, GetClassName retrieves the class name of
  *   that window. GetClassName is called from WinMain in this application.
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     char  szClassName[30];  /* buffer to receive Class Name of hWnd */
     int   nSizeBuff;    /*   return value from GetClassName  */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"GetClassName",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );


 /*** get the class name of the window associated with hWnd ***/
     nSizeBuff = GetClassName(hWnd,(LPSTR)szClassName,30);


     if (nSizeBuff == 0)
    {
    MessageBox(hWnd,(LPSTR)"is not valid ",
         (LPSTR)"The specified window handle",
         MB_OK);
    return 1;
    }

      MessageBox(hWnd,(LPSTR)szClassName,
     (LPSTR)"The class name is:",
     MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETCRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETCRECT.C

 #include "windows.h"

 int PASCAL WinMain(HANDLE, HANDLE, LPSTR, int);
 BOOL GetCRectInit(HANDLE);
 long FAR PASCAL GetCRectWndProc(HWND, unsigned, WORD, LONG);

 HANDLE hInst;

 /**************************************************************************/

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;           /* current instance             */
 HANDLE hPrevInstance;       /* previous instance            */
 LPSTR lpCmdLine;            /* command line                 */
 int nCmdShow;               /* show-window type (open/icon) */
 {
     HWND hWnd;              /* window handle                */
     MSG msg;                /* message                      */


     if (!hPrevInstance)     /* Has application been initialized? */
         if (!GetCRectInit(hInstance))
             return (NULL);  /* Exits if unable to initialize     */

     hInst = hInstance;      /* Saves the current instance        */

     hWnd = CreateWindow("GetCRect",     /* window class            */
         "GetCRect Sample Application",  /* window name             */
         WS_OVERLAPPEDWINDOW,           /* window style            */
         CW_USEDEFAULT,                 /* x position              */
         CW_USEDEFAULT,                 /* y position              */
         CW_USEDEFAULT,                 /* width                   */
         CW_USEDEFAULT,                 /* height                  */
         NULL,                          /* parent handle           */
         NULL,                          /* menu or child ID        */
         hInstance,                     /* instance                */
         NULL);                         /* additional info         */

     if (!hWnd)                         /* Was the window created? */
         return (NULL);

     ShowWindow(hWnd, nCmdShow);        /* Shows the window        */
     UpdateWindow(hWnd);                /* Sends WM_PAINT message  */

     while (GetMessage(&msg,     /* message structure                      */
             NULL,               /* handle of window receiving the message */
             NULL,               /* lowest message to examine              */
             NULL))              /* highest message to examine             */
         {
         TranslateMessage(&msg); /* Translates virtual key codes           */
         DispatchMessage(&msg);  /* Dispatches message to window           */
     }
     return (msg.wParam);        /* Returns the value from PostQuitMessage */
 }


 /*************************************************************************/

 BOOL GetCRectInit(hInstance)
 HANDLE hInstance;                 /* current instance           */
 {
     HANDLE hMemory;               /* handle to allocated memory */
     PWNDCLASS pWndClass;          /* structure pointer          */
     BOOL bSuccess;                /* RegisterClass() result     */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = GetCRectWndProc;
     pWndClass->hInstance = hInstance;
     pWndClass->hIcon = NULL;
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->lpszMenuName = (LPSTR) "GetCRectMenu";
     pWndClass->lpszClassName = (LPSTR) "GetCRect";

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);                           /* Unlocks the memory
     LocalFree(hMemory);                             /* Returns it to Windows

     return (bSuccess);           /* Returns result of registering the window
 }

 /**************************************************************************/

 long FAR PASCAL GetCRectWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                      /* window handle                   */
 unsigned message;               /* type of message                 */
 WORD wParam;                    /* additional information          */
 LONG lParam;                    /* additional information          */
 {
     FARPROC lpProcAbout;        /* pointer to the "About" function */
     HMENU hMenu;                /* handle to the System menu       */
     RECT  rRect;                /* Will hold client rectangle  */
     HANDLE hDC;                 /* Handle to the display context  */
     PAINTSTRUCT ps;             /* Paint Structure  */

     switch (message) {
         case WM_SIZE:
         case WM_PAINT:
             GetClientRect( hWnd,           /*  Window handle  */
                          (LPRECT)&rRect ); /*  Structure holding  */
             InvalidateRect( hWnd, (LPRECT)&rRect, TRUE );
                                /*  Erase the background  */
             hDC = BeginPaint ( hWnd, &ps );   /*  Get the display context  */
 /*  We are going to draw an X through the window  */
             MoveTo( hDC, rRect.left, rRect.top );
             LineTo( hDC, rRect.right, rRect.bottom );
             MoveTo( hDC, rRect.right, rRect.top );
             LineTo( hDC, rRect.left, rRect.bottom );
             EndPaint( hWnd, &ps );
             break;

         case WM_DESTROY:                  /* message: window being destroyed
             PostQuitMessage(0);
             break;

         default:                          /* Passes it on if unproccessed
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }




 GETCSTAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\GETCSTAT.C

 /*
  *
  *  GetCommState
  *
  *  This program demonstrates the use of the function GetCommState.
  *  This function fills the buffer pointed to by the last parameter with the
  *  device control block of the communication device specified by the first
  *  parameter.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int nCid;
   WORD lpResult;
   DCB CommDCB;

   nCid = OpenComm ( (LPSTR)"COM1", 50, 50);
   if ( nCid < 0 )
      {
      MessageBox (NULL, (LPSTR)"OpenComm Failed", (LPSTR)"OpenComm",
         MB_OK|MB_ICONEXCLAMATION);
      exit (1);
      }

   CommDCB.BaudRate = 9600;
   CommDCB.ByteSize = 8;
   CommDCB.StopBits = ONESTOPBIT;
   CommDCB.TxDelay = 10;
   CommDCB.Parity = NOPARITY;
   CommDCB.PeChar = 0;
   CommDCB.RlsTimeout = 1000;
   CommDCB.CtsTimeout = 1000;
   CommDCB.DsrTimeout = 1000;
   CommDCB.XonChar = 2;
   CommDCB.XoffChar = 3;
   CommDCB.XonLim = 1000;
   CommDCB.XoffLim = 1000;
   CommDCB.EofChar = 4;
   CommDCB.EvtChar = 5;

   SetCommState( (DCB FAR *)&CommDCB );

   MessageBox (NULL, (LPSTR)"Requesting communication port state",
      (LPSTR)"GetCommState", MB_OK);

   lpResult = GetCommState ( nCid, (DCB FAR *)&CommDCB );

   if ( lpResult == 0 )
      MessageBox (NULL, (LPSTR)"Communication port state received",
                 (LPSTR)"GetCommState", MB_OK);
   else
      MessageBox (NULL, (LPSTR)"Error when getting state",
         (LPSTR)"GetCommState", MB_OK);

   CloseComm ( nCid );

   return 0;
 }


 GETCTASK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETCTASK.C

 /*
  *  GetCurrentTask
  *
  *  This program will get the handle to the current task and send it a
  *  message to kill itself.
  *
  */

  "windows.h"      /* required for all Windows applications */
 #include "getctask.h"

 HANDLE hInst;             /* current instance                      */

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;         /* current instance             */
 HANDLE hPrevInstance;     /* previous instance            */
 LPSTR lpCmdLine;          /* command line                 */
 int nCmdShow;             /* show-window type (open/icon) */
 {
     HWND hWnd;            /* window handle       */
     MSG msg;              /* message             */
     HANDLE hMenu;         /* Handle to the menu  */

     if (!hPrevInstance)              /* Has application been initialized? */
         if (!GetCTaskInit(hInstance))
             return (NULL);           /* Exits if unable to initialize     */

     hInst = hInstance;               /* Saves the current instance        */

     hMenu = LoadMenu( hInst, (LPSTR)"GetCTaskMenu" );
                                      /*  Load the menu    */

     hWnd = CreateWindow("GetCTask",   /* window class      */
         "GetCurrentTask Sample Application",  /* window name       */
         WS_OVERLAPPEDWINDOW,         /* window style      */
         CW_USEDEFAULT,               /* x position        */
         CW_USEDEFAULT,               /* y position        */
         CW_USEDEFAULT,               /* width             */
         CW_USEDEFAULT,               /* height            */
         NULL,                        /* parent handle     */
         hMenu,                       /* menu or child ID  */
         hInstance,                   /* instance          */
         NULL);                       /* additional info   */

     if (!hWnd)                       /* Was the window created? */
         return (NULL);

     ShowWindow(hWnd, nCmdShow);      /* Shows the window        */
     UpdateWindow(hWnd);              /* Sends WM_PAINT message  */

     while (GetMessage(&msg,     /* message structure                      */
             NULL,               /* handle of window receiving the message */
             NULL,               /* lowest message to examine              */
             NULL))              /* highest message to examine             */
         {
         TranslateMessage(&msg);  /* Translates virtual key codes           */
         DispatchMessage(&msg);   /* Dispatches message to window           */
     }
     return (msg.wParam);         /* Returns the value from PostQuitMessage */
 }

 BOOL GetCTaskInit(hInstance)
 HANDLE hInstance;                /* current instance           */
 {
     HANDLE hMemory;              /* handle to allocated memory */
     PWNDCLASS pWndClass;         /* structure pointer          */
     BOOL bSuccess;               /* RegisterClass() result     */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = GetCTaskWndProc;
     pWndClass->hInstance = hInstance;
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->lpszMenuName = (LPSTR) "GetCTaskMenu";
     pWndClass->lpszClassName = (LPSTR) "GetCTask";

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);     /* Unlocks the memory    */
     LocalFree(hMemory);       /* Returns it to Windows */

     return (bSuccess);        /* Returns result of registering the window */
 }

 long FAR PASCAL GetCTaskWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                    /* window handle                   */
 unsigned message;             /* type of message                 */
 WORD wParam;                  /* additional information          */
 LONG lParam;                  /* additional information          */
 {
     FARPROC lpProcAbout;      /* pointer to the "About" function */
     HMENU hMenu;              /* handle to the System menu       */

     switch (message) {

         case WM_COMMAND:
             if ( wParam == IDM_TRASH )
               {
               PostAppMessage( GetCurrentTask( ),  /*  Get current task  */
                               WM_QUIT,      /*  Message to quit  */
                               NULL,         /*  wParam  */
                               (LONG)NULL);  /*  lParam  */
               }
             break;

 /*  PostMessage places the message into the applications message queue and
  *  does not wait for a response.  This is different from the SendMessage
  *  function in that SendMessage does wait.  The Window Procedure is called
  *  immediately when SendMessage is used.  For more information see
  *  PostMessage and SendMessage in the Programmer's Reference.
  */
         case WM_DESTROY:             /* message: window being destroyed */
             PostQuitMessage(0);
             break;

         default:                     /* Passes it on if unproccessed    */
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }


 GETCTIME.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TIME\GETCTIME.C

 /*
  *
  *  GetCurrentTime
  *
  *  This program demonstrates the use of the function GetCurrentTime.
  *  This function retrieves the current Window time.
  *
  *
  */

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   DWORD dwCurTime;
   char szbuff[80];

   MessageBox (NULL, (LPSTR)"Getting current time", (LPSTR)"GetCurrentTime",
      MB_OK);

   dwCurTime = GetCurrentTime ();

   sprintf ( szbuff, "The current time in milliseconds is %ld",
      dwCurTime );
   MessageBox (NULL, (LPSTR) szbuff, (LPSTR)"GetCurrentTime", MB_OK);

   return FALSE;
 }


 GETCWIDT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GETCWIDT.C

 /*
  *
  *  GetCharWidth
  *
  *  This program demonstrates the use of the function GetCharWidth.
  *  This function retrieves the widths of individual characters in a
  *  consecutive group of characters from the current font.  The funtion
  *  stores the values in the buffer pointed to by the last parameter.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HDC hDC;
   PAINTSTRUCT ps;
   BOOL bCharWidth;
   WORD wFirstChar = 97;
   WORD wLastChar = 122;
   char szbuff[80];
   int  lpBuffer[26];
   int  CharWidthSum, CharWidth, Index;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "getcwidt";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) "getcwidt", ( LPSTR ) "GetCharWidth",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   BeginPaint ( hWnd, ( LPPAINTSTRUCT ) &ps );
   hDC = ps.hdc;

   MessageBox (NULL, (LPSTR)"Getting charater string width",
      (LPSTR)"GetCharWidth", MB_OK);

   bCharWidth = GetCharWidth ( hDC, wFirstChar, wLastChar,(LPINT) lpBuffer );
   for (Index = 0, CharWidthSum = 0; Index < 26; Index++) {
     CharWidthSum += lpBuffer [Index];
   }
   CharWidth = CharWidthSum / 26;
   sprintf (szbuff, "The average character width is %i", CharWidth);
   MessageBox (hWnd, szbuff, "GetCharWidth", MB_OK);

   return 0;
 }


 GETCWORD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\GETCWORD.C

 /*
  *
  *  GetClassWord
  *
  *  This program demonstrates the use of the function GetClassWord.
  *  This function retrieves the word that is specified by the last para-
  *  meter form the WNDCLASS stucture of the window specified by the
  *  first parameter.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   WORD wClassWord;
   char szbuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "getcword";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) "getcword", ( LPSTR ) "GetClassWord",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );

   MessageBox (NULL, (LPSTR)"Getting windows style bits",
      (LPSTR)"GetClassWord", MB_OK);

   wClassWord = GetClassWord ( hWnd, GCW_STYLE );

   sprintf ( szbuff, "%s%d\0", "Style bits are ", wClassWord );

   MessageBox (NULL, (LPSTR) szbuff, (LPSTR)"GetClassWord", MB_OK);

   return 0;
 }


 GETDCAPS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DEVICE\GETDCAPS.C

 /*
  *
  *  GetDeviceCaps
  *
  *  This program demonstrates the use of the function GetDeviceCaps.
  *  This function retrieves device-specific information about a given
  *  display device.  The last parameter specifies the type os information
  *  desired.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HDC hDC;
   short nValue;
   char szbuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "getdcaps";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) "getdcaps", ( LPSTR ) "GetDeviceCaps",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hDC = GetDC ( hWnd );

   MessageBox (NULL, (LPSTR)"Getting driver version number",
              (LPSTR)"GetDeviceCaps", MB_OK);

   nValue = GetDeviceCaps ( hDC, DRIVERVERSION );

   sprintf ( szbuff, "%s%d\0", "Driver version number is ",
      nValue );
   MessageBox (NULL, (LPSTR) szbuff, (LPSTR)"GetDeviceCaps", MB_OK);

   ReleaseDC ( hWnd, hDC );

   return 0;
 }


 GETDCORG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DEVICE\GETDCORG.C

 /*
  *  GetDCOrg
  *
  *  This program demonstrates the use of the function GetDCOrg.
  *  This function obtians the final translation origin for the device
  *  context.
  *
  *  Microsoft Product Support Services
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HDC hDC;
   LONG ptOrigin;
   char szbuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "getdcorg";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) "getdcorg", ( LPSTR ) "GetDCOrg",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hDC = GetDC ( hWnd );

   MessageBox (NULL, (LPSTR)"Getting origin", (LPSTR)"GetDCOrg", MB_OK);

   ptOrigin = GetDCOrg ( hDC );

   sprintf ( szbuff, "The origin of this window is at (%d,%d)",
      LOWORD(ptOrigin), HIWORD(ptOrigin) );
   MessageBox (NULL, (LPSTR) szbuff, (LPSTR)"GetDCOrg", MB_OK);

   ReleaseDC ( hWnd, hDC );

   return 0;
 }


 GETDCPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DISPLAY\GETDCPOS.C

 /*

 Function(s) demonstrated in this program: GetCurrentPosition

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns the current position of the Display
    Context.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetDCPos.h"


 HWND     hWndParent1, hWndParent2, hWndChild1, hWndChild2;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetCurrentPosition Windows function.",

 "Help Message",
 "     This program uses the GetCurrentPosition Windows\n\
 function return the current position of the Display\n\
 context, this position is then displayed in a Message\n\
 Box.  The position has been moved to (x,y) = (100,100)\n\
 so this should be displayed when option is chosen\n\
 from the menu.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetDCPos" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetCurrentPosition",       /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  DWORD       dWord;
  char        szOutputBuffer [40];

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETPOSITION:
                hDC = GetDC ( hWnd );
                MoveTo ( hDC, 100, 100 );
                dWord = GetCurrentPosition (hDC);
                sprintf (szOutputBuffer1,
                       "The Current Display Context Position = (%i,%i)",
                         LOWORD (dWord), HIWORD (dWord));
                MessageBox (hWnd, szOutputBuffer1, "GetCurrentPostion", MB_OK)
                ReleaseDC(hWnd, hDC);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }



 GETENV.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GETENV.C

 /*
  *
  *  GetEnvironment
  *  getenv.c
  *
  *  This program demonstrates the use of the function GetEnvironment.
  *  This function retrieves the currewnt environment that is associated with
  *  the device attached to the system port specified by the first parameter,
  *  and copies it into the buffer specified by the second parameter.
  *
  */

 #include <windows.h>
 #include "getenv.h"

 LPSTR far PASCAL lstrcpy( LPSTR, LPSTR );

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   short nCopied;
   short nSCopied;
   DEVMODE devmode;

   lstrcpy(devmode.DeviceName, "HP LaserJet Series II");
   devmode.orient = PORTRAIT;
   devmode.cartridge = DEFAULT_CTG + CARTRIDGE;
   devmode.paper = LETTER;

   nSCopied = SetEnvironment("LPT1:", (LPSTR)&devmode, sizeof(DEVMODE));
   if (!nSCopied)
      {
      MessageBox (NULL, "Environment not set!", "SetEnvironment",
         MB_OK|MB_ICONEXCLAMATION);
      return (1);
      }

   /* Clear out name string to show that we can retrieve it */
   lstrcpy(devmode.DeviceName, "xxxxxxxxxxxxxx");

   MessageBox(NULL, "Getting environment", "GetEnvironment", MB_OK);
   nCopied=GetEnvironment("LPT1:", (LPSTR)&devmode, sizeof(DEVMODE));

   if (nCopied)
      MessageBox(NULL, devmode.DeviceName, "DeviceName", MB_OK);
   else
      MessageBox(NULL, "Environment not found", "GetEnvironment", MB_OK);

   return 0;
 }


 GETHDC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DISPLAY\GETHDC.C

 /*

 Function(s) demonstrated in this program: GetDC
 Windows version:  2.03
 Windows SDK version:  2.00
 Compiler version:  C 5.10
 Description:  This function returns a handle to the display context.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GethDC.h"


 HWND     hWndParent1, hWndParent2, hWndChild1, hWndChild2;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetDC Windows function.",

 "Help Message",
 "     This program uses the GetDC Windows function\n\
 to get a handle to the current display context this\n\
 handle is then displayed in a message box.  Use\n\
 the menu to invoke this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GethDC" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetDC",                    /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETHDC:
                hDC = GetDC (hWnd);
                sprintf (szOutputBuffer1,
                         "The Handle to the display context is %x", hDC);
                MessageBox (hWnd, szOutputBuffer1, "GetDC", MB_OK);
                ReleaseDC(hWnd, hDC);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETLEN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\GETLEN.C

 /*
  *   GetWindowTextLength
  *
  *   This program demonstrates the use of the GetWindowTextLength function.
  *   The GetWindowTextLength function returns the length of the text in the
  *   given window's caption bar. If the return value is 0, then there is
  *   no text in the caption bar.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     int x;         /* return value from GetWindowTextLength  */
     char buffer[40];       /* buffer for outputing text    */

   HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

       /* get caption bar text length */
       x=GetWindowTextLength(hWnd);
       /* if there is a caption */
       if (x>0)
          {
          /* copy length to buffer */
          sprintf(buffer,"length of text in caption bar = %d",x);
          /* output the caption  */
          MessageBox(hWnd,(LPSTR)buffer,
         (LPSTR)"CAPTION BAR INFO",MB_OK);
          }
       else
       /* output "There is no Title Bar */
     MessageBox(hWnd,(LPSTR)NULL,
         (LPSTR)"There is no Title Bar",MB_OK);


     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
   {
    default:
             return DefWindowProc( hWnd, message, wParam, lParam );
       break;
   }
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETMAPM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MAP\GETMAPM.C

 /*
  *
  *  GetMapMode
  *
  *  This program demonstrates the use of the function GetMapMode.
  *  This function retrieves the cuurent mapping mode.
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HDC hDC;
   static char szFileName[] = "getmapm";
   static char szFuncName[] = "GetMapMode";
   short nMapMode;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) szFileName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) szFileName, ( LPSTR ) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hDC = GetDC ( hWnd );
   SetMapMode ( hDC, MM_TEXT);

   MessageBox (NULL, (LPSTR)"Getting mapping mode", (LPSTR)szFuncName, MB_OK);

   nMapMode = GetMapMode ( hDC );

   if ( nMapMode == MM_ANISOTROPIC )
      MessageBox (NULL, (LPSTR)"Mapping mode is anisotropic" ,
         (LPSTR)szFuncName, MB_OK);
   else
      if ( nMapMode == MM_HIENGLISH )
         MessageBox (NULL, (LPSTR)"Mapping mode is high english" ,
            (LPSTR)szFuncName, MB_OK);
      else
         if ( nMapMode == MM_HIMETRIC )
            MessageBox (NULL, (LPSTR)"Mapping mode is high metric" ,
               (LPSTR)szFuncName, MB_OK);
         else
            if ( nMapMode == MM_ISOTROPIC )
               MessageBox (NULL, (LPSTR)"Mapping mode is isotropic" ,
                  (LPSTR)szFuncName, MB_OK);
            else
               if ( nMapMode == MM_LOMETRIC )
                  MessageBox (NULL, (LPSTR)"Mapping mode is low metric" ,
                     (LPSTR)szFuncName, MB_OK);
               else
                  if ( nMapMode == MM_LOENGLISH )
                     MessageBox (NULL, (LPSTR)"Mapping mode is low english" ,
                        (LPSTR)szFuncName, MB_OK);
                  else
                     if ( nMapMode == MM_TEXT )
                        MessageBox (NULL, (LPSTR)"Mapping mode is text" ,
                           (LPSTR)szFuncName, MB_OK);
                     else
                        if ( nMapMode == MM_TWIPS )
                           MessageBox (NULL, (LPSTR)"Mapping mode is twips" ,
                              (LPSTR)szFuncName, MB_OK);
                        else
                           MessageBox (NULL, (LPSTR)"Error no mapping mode" ,
                              (LPSTR)szFuncName, MB_OK|MB_ICONEXCLAMATION);

   ReleaseDC ( hWnd, hDC );

   return 0;
 }


 GETMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GETMENU.C

 /*
  *
  *  GetMenu
  *
  *  This program demonstrates the use of the function GetMenu.
  *  This function retrieves a handle to the menu of the specified window.
  *
  */

 #include <windows.h>
 #include "getmenu.h"

 long FAR PASCAL GMWndProc (HWND, unsigned int, WORD, LONG);

 static HANDLE hWnd;

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFileName[] = "getmenu";
   static char szFuncName[] = "GetMenu";
   MSG   msg;
   HMENU hMenu;

   if (!hPrevInstance)
      {
      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)szFileName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon         = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)"GetMenuFunc";
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);
      }

   hWnd = CreateWindow((LPSTR)szFileName, (LPSTR)szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND)NULL, (HMENU)NULL,
                       (HANDLE)hInstance, (LPSTR)NULL);

    ShowWindow(hWnd, cmdShow);
    UpdateWindow(hWnd);

    MessageBox(GetFocus(), (LPSTR)"Getting Menu Handle",
               (LPSTR)"GetMenu()", MB_OK);
    hMenu = GetMenu(hWnd);
    if (hMenu == NULL)
       MessageBox(GetFocus(), (LPSTR)"Error In Getting Menu Handle",
                  (LPSTR)"GetMenu()", MB_OK);
    else
       MessageBox(GetFocus(), (LPSTR)"Menu Handle Obtained Successfully",
                  (LPSTR)"GetMenu()", MB_OK);
    EnableMenuItem(hMenu, ENTRY_1, MF_BYCOMMAND | MF_GRAYED);
    DrawMenuBar(hWnd);
    MessageBox(GetFocus(), (LPSTR)"'Item_1' Grayed",
               (LPSTR)"GetMenu()", MB_OK);

   return 0;
 }



 GETMOD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MODULE\GETMOD.C

 /*

 Function(s) demonstrated in this program: GetModuleFileName, GetModuleHandle,
   GetModuleUsage

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns the reference count of the module.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetMod.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetModuleFileName, GetModuleHandle, and\n\
 GetModuleUsage Windows functions.",

 "Help Message",
 "     This program uses the GetModuleUsage Windows\n\
 function to get the reference count of the current\n\
 module.  To test this function, first start several\n\
 instances of this program.  Then use the menu to\n\
 invoke the function.  The count displayed should\n\
 directly represent the number of instances you have\n\
 started.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetMod" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetModuleUsage",           /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  int         nUsage;
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  HANDLE      hModule;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETMODF:
                GetModuleFileName(GetModuleHandle((LPSTR)"GetMod"),
                                  szOutputBuffer1, 70);
                MessageBox (hWnd, szOutputBuffer1, "GetModuleFileName", MB_OK)
                break;

           case IDM_GETMODH:
                hModule = GetModuleHandle ("GetMod");
                sprintf (szOutputBuffer1, "Module handle = %x", hModule);
                MessageBox (hWnd, szOutputBuffer1, "GetModuleHandle", MB_OK);
                break;

           case IDM_GETMODU:
                nUsage = GetModuleUsage (hInstMain);
                sprintf (szOutputBuffer1,
                         "The module usage of the current module = %i",nUsage)
                MessageBox (hWnd, szOutputBuffer1, "GetModuleUsage", MB_OK);
                break;


           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\GETMSG.C

 /*
  *
  *  GetMessage
  *
  *  This program demonstrates the use of the GetMessage function.  The
  *   program registers and creates a window.  Then, it goes into the
  *   GetMessage loop.  On the screen is the instruction to double click
  *   the right mouse button.  This conducts the test of GetMessage by
  *   displaying a message box from within the WM_RBOTTONDBLCLK section
  *   of the window procedure .
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getmsg";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);

      /* Permit the window class to accept double click messages by
         using the CS_DBLCLKS style.                                */

      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getmsg",
            (LPSTR) "GetMessage",
            WS_OVERLAPPEDWINDOW,          /* Use an overlapping window. */
            CW_USEDEFAULT,                /* Use default coordinates.   */
            CW_USEDEFAULT,                /* Use default coordinates.   */
            CW_USEDEFAULT,                /* Use default coordinates.   */
            CW_USEDEFAULT,                /* Use default coordinates.   */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    /* Go into the GetMessage loop at this time.  The user can then
       double click on the right mouse button when the cursor is in
       the client area of this application.                         */

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    switch (identifier) {

      case WM_PAINT: {
         RECT      rRect;
         PAINTSTRUCT ps;
         HDC      hDC;

         hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);

          /* Display the instructions in the client area for the
             user to conduct the test.                            */

        DrawText(hDC,
                   (LPSTR)"Double Click Right Mouse Button to Conduct Test.",
                   48,
                   (LPRECT)&rRect,
                   DT_SINGLELINE);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);

     }
     break;

      /* Check to see if the user has double clicked the right
         mouse button.                                          */

     case WM_RBUTTONDBLCLK:        /* If so, display a success message box. */
       MessageBox(hWnd,
                  (LPSTR)"GetMessage Retrieved a WM_RBUTTONDBLCLK Message",
                  (LPSTR)"GetMessage",
                  MB_OK);
       break;                    /* And return for more message processing. */

     case WM_CLOSE:
      DestroyWindow(hWnd);
      break;

     case WM_DESTROY:
      PostQuitMessage(0);
      break;

     default:
      return(DefWindowProc(hWnd, identifier, wParam, lParam));
      break;

    }

    return(0L);

 }


 GETOBJ.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\OBJECT\GETOBJ.C

 /*
  *
  *  GetObject
  *  getobj.c
  *
  *  This program demonstrates the use of the function GetObject.
  *  This funtion fills a buffer with the logical data the defines the
  *  logical object specified by the first parameter.
  *
  *  Other references: cfclip.c, cfnew.c
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   long    dwCopied;
   long    dwCount;
   HBITMAP hBitmap;
   BITMAP  bitmap;
   char    szJunk[50];

   hBitmap = LoadBitmap(hInstance, "SCOTTIE");

   MessageBox (NULL, "Getting object ", "GetObject", MB_OK);
   dwCount = GetObject(hBitmap, (long)sizeof(BITMAP), (LPSTR) &bitmap);

   if (dwCount)
      {
      sprintf(szJunk, "Bitmap Width=%d, Height=%d",
        bitmap.bmWidth, bitmap.bmHeight);
      MessageBox(NULL, szJunk, "GetObject Successful", MB_OK);
      }
   else
      MessageBox(NULL, "Object not gotten", "GetObject", MB_OK);

   return 0;
 }


 GETOBJ.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETOBJ.C

 /*
  *
  *  GetObject
  *  getobj.c
  *
  *  This program demonstrates the use of the function GetObject.
  *  This funtion fills a buffer with the logical data the defines the
  *  logical object specified by the first parameter.
  *
  *  Other references: cfclip.c, cfnew.c
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   long    dwCopied;
   long    dwCount;
   HBITMAP hBitmap;
   BITMAP  bitmap;
   char    szJunk[50];

   hBitmap = LoadBitmap(hInstance, "SCOTTIE");

   MessageBox (NULL, "Getting object ", "GetObject", MB_OK);
   dwCount = GetObject(hBitmap, (long)sizeof(BITMAP), (LPSTR) &bitmap);

   if (dwCount)
      {
      sprintf(szJunk, "Bitmap Width=%d, Height=%d",
        bitmap.bmWidth, bitmap.bmHeight);
      MessageBox(NULL, szJunk, "GetObject Successful", MB_OK);
      }
   else
      MessageBox(NULL, "Object not gotten", "GetObject", MB_OK);

   return 0;
 }


 GETOPWND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETOPWND.C

 /*
  *
  *   This program demonstrates the use of the GetTopWindow() function.
  *   GetTopWindow() searches for the top level child window that belongs
  *   to the parent window specified by the "hWnd" parameter. GetTopWindow()
  *   is called twice in WinMain(). It is first called when no child windows
  *   exist, and then after two child windows have been created.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ChildAProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ChildBProc(HWND, unsigned, WORD, LONG);

 HWND hChildAWnd = NULL;
 HWND hChildBWnd = NULL;

 /* Procedure called when the application is loaded for the first time */

 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"GetTopWindow";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"CHILD A";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = ChildAProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"CHILD B";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = ChildBProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HWND  hTopWindow;    /*** return value from GetTopWindow() ***/

     HelloInit( hInstance );

     hWnd = CreateWindow((LPSTR)"GetTopWindow",
       (LPSTR)"GetTopWindow()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(NULL,
          (LPSTR)"Will destroy window if handle returned.",
          (LPSTR)"First call to GetTopWindow().",
          MB_OK);

 /*** get handle to top level child to "hWnd" (if one exists) ***/
     hTopWindow = GetTopWindow(hWnd);
     if (hTopWindow)
   DestroyWindow(hTopWindow);
     else
   MessageBox(NULL,
        (LPSTR)"No top level child window exists",
        (LPSTR)"GetTopWindow() info:",
        MB_OK);

     hChildAWnd = CreateWindow((LPSTR)"CHILD A",
       (LPSTR)"Child A",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION |
       WS_CLIPSIBLINGS,
       5,
       5,
       250,
       250,
       (HWND)hWnd,
       (HMENU)1,     /* child: use constant */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     hChildBWnd = CreateWindow((LPSTR)"CHILD B",
       (LPSTR)"Child B",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION |
       WS_CLIPSIBLINGS,
       5,
       5,
       150,
       150,
       (HWND)hChildAWnd,
       (HMENU)2,     /* child: use constant */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     MessageBox(NULL,
          (LPSTR)"Will destroy window if handle returned.",
          (LPSTR)"Second call to GetTopWindow().",
          MB_OK);

 /*** get handle to top level child to "hWnd" (if one exists) ***/
     hTopWindow = GetTopWindow(hWnd);
     if (hTopWindow)
   DestroyWindow(hTopWindow);
     else
   MessageBox(NULL,
        (LPSTR)"No top level child window exists",
        (LPSTR)"GetTopWindow() info:",
        MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 long FAR PASCAL ChildAProc( hChildAWnd, message, wParam, lParam )
 HWND hChildAWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
   BeginPaint( hChildAWnd, (LPPAINTSTRUCT)&ps );
   EndPaint( hChildAWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
   return DefWindowProc( hChildAWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 long FAR PASCAL ChildBProc( hChildBWnd, message, wParam, lParam )
 HWND hChildBWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
   BeginPaint( hChildBWnd, (LPPAINTSTRUCT)&ps );
   EndPaint( hChildBWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
   return DefWindowProc( hChildBWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETPADDR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\GETPADDR.C

 /*

 Function(s) demonstrated in this program: GetProcAddress, LoadLibrary,
    FreeLibrary

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns a handle to the given library function.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetPAddr.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetProcAddress, LoadLibrary, and FreeLibrary\n\
 Windows functions.",

 "Help Message",
 "     This program uses the GetProcAddress Windows\n\
 function to get a handle to the StartSelection\n\
 function in the SELECT library.  This address is\n\
 then displayed in a message box.  Use the menu to\n\
 invoke this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetPAddr" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetProcAddress",           /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  HANDLE      hLibModule;
  FARPROC     lpAddress;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETPROCADDRESS:
                hLibModule = LoadLibrary( "select" );

                MessageBox (NULL,
                  (LPSTR)"Retrieving address of the StartSelection function.",
                  (LPSTR)"GetProcAddress", MB_OK);

                lpAddress = GetProcAddress( hLibModule, "StartSelection" );

                if ( lpAddress != NULL ) {
                   sprintf (szOutputBuffer1,
                            "The Address of StartSelection is %x",
                            lpAddress);
                   MessageBox (NULL, szOutputBuffer1, "GetProcAddress", MB_OK)
                }
                else
                   MessageBox (NULL,
                               "Error detected while searching for address.",
                               "GetProcAddress", MB_OK);

                FreeLibrary ( hLibModule );

                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETPARNT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\GETPARNT.C

 /*
  *
  *   This program demonstrates use of the GetParent() function.
  *   GetParent() returns the parent (if one exists) of the given window.
  *   GetParent() is called three times in WinMain() in this application.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ChildAProc(HWND, unsigned, WORD, LONG);
 long FAR PASCAL ChildBProc(HWND, unsigned, WORD, LONG);

 HWND hChildAWnd = NULL;     /*  handle to child window       */
 HWND hChildBWnd = NULL;     /*  handle to grandchild window  */
 HWND hMainWnd = NULL;       /*   handle to main window        */

 /* Procedure called when the application is loaded for the first time */

 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"GetParent";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"CHILD A";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = ChildAProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"CHILD B";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc  = ChildBProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HWND  hParent;  /* return value from GetParent() */

     HelloInit( hInstance );

     hMainWnd = CreateWindow((LPSTR)"GetParent",
       (LPSTR)"GetParent() [hMainWnd]",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hMainWnd, cmdShow );
     UpdateWindow( hMainWnd );

     hChildAWnd = CreateWindow((LPSTR)"CHILD A",
       (LPSTR)"Child A [hChildAWnd]",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION |
       WS_CLIPSIBLINGS,
       5,
       5,
       400,
       300,
       (HWND)hMainWnd,
       (HMENU)1,     /* child: use constant */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     hChildBWnd = CreateWindow((LPSTR)"CHILD B",
       (LPSTR)"Child B [hChildBWnd]",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION |
       WS_CLIPSIBLINGS,
       5,
       5,
       300,
       250,
       (HWND)hChildAWnd,
       (HMENU)2,     /* child: use constant */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

 /*
  *     hWnd is the parent of hChildAWnd and hChildAWnd is the parent of
  *     hChildBWnd. The following calls to GetParent() should confirm this
  */

 hParent = GetParent(hMainWnd);
 if (!hParent)
     MessageBox(NULL,
          (LPSTR)"because hMainWnd has no parent",
          (LPSTR)"GetParent(hMainWnd) returned NULL, which is correct...",
          MB_OK);
 else
     MessageBox(NULL,
          (LPSTR)"which is an ERROR",
          (LPSTR)"GetParent(hWnd) did not return NULL...",
          MB_OK);

 hParent = GetParent(hChildAWnd);
 if (hParent == hMainWnd)
     MessageBox(NULL,
          (LPSTR)"because hMainWnd is hChildAWnd's parent",
          (LPSTR)"GetParent(hChildAWnd) returned hMainWnd, which is correct...
          MB_OK);
 else
     MessageBox(NULL,
          (LPSTR)"which is an ERROR",
          (LPSTR)"GetParent(hChildAWnd) did not return hMainWnd,",
          MB_OK);

 hParent = GetParent(hChildBWnd);
 if (hParent == hChildAWnd)
     MessageBox(NULL,
          (LPSTR)"because hChildAWnd is hChildBWnd's parent",
          (LPSTR)"GetParent(hChildBWnd) returned hChildAWnd, which is correct.
          MB_OK);
 else
     MessageBox(NULL,
          (LPSTR)"which is an ERROR",
          (LPSTR)"GetParent(hChildBWnd) did not return hChildAWnd",
          MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
   break;

     case WM_LBUTTONDOWN:
   MessageBox(hChildBWnd,(LPSTR)"Left Button Click",
             (LPSTR)"PARENT WINDOW",
             MB_OK);
   break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 long FAR PASCAL ChildAProc( hChildAWnd, message, wParam, lParam )
 HWND hChildAWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_LBUTTONDOWN:
   MessageBox(hChildBWnd,(LPSTR)"Left Button Click",
             (LPSTR)"CHILD A",
             MB_OK);
   break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
   BeginPaint( hChildAWnd, (LPPAINTSTRUCT)&ps );
   EndPaint( hChildAWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
   return DefWindowProc( hChildAWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 long FAR PASCAL ChildBProc( hChildBWnd, message, wParam, lParam )
 HWND hChildBWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_LBUTTONDOWN:
   MessageBox(hChildBWnd,(LPSTR)"Left Button Click",
             (LPSTR)"CHILD B",
             MB_OK);
   break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
   BeginPaint( hChildBWnd, (LPPAINTSTRUCT)&ps );
   EndPaint( hChildBWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
   return DefWindowProc( hChildBWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETPIXEL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETPIXEL.C

 /*

 Function(s) demonstrated in this program: ChildWindowFromPoint

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function retrieves the RGB color value of the pixel at
    the point specified by the X and Y parameters.  If the point is not in
    the clipping region, the function is ignored.

 Additional Comments:  This program also illustrates the subclassing of
     windows.

 */

 #define NOMINMAX
 #include <stdlib.h>
 #include <windows.h>
 #include "GetPixel.h"
 #include "string.h"
 #include "stdio.h"

        char         szAppName             [] = "GetPixel"          ;
        HANDLE       hInstMain                                      ;
        HWND         hWndMain                                       ;
        char         szOutputBuffer1       [70]                     ;
        char         szOutputBuffer2       [500]                    ;
        HBITMAP      hBitmapHelp                                    ;

        HWND         hWndChild1, hWndChild2, hX, hY, hOK2;
        FARPROC      lpProcEnterPoint;
        FARPROC      lpProcNewEnterPoint;
        FARPROC      lpProcOldX;
        FARPROC      lpProcOldY;
        char         szXValue [40];
        char         szYValue [40];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     Sample Application to demonstrate the use of\n\
 the GetPixel Windows function.",

 "Help Message",
 "     Select a pixel, and the program will use the\n\
 GetPixel Windows function to display the attributes\n\
 of that pixel; ffff = White, 0 = Black.  Select a\n\
 pixel by clicking the left mouse button, entering\n\
 the pixel coordinates through the keyboard, or let\n\
 the computer choose random pixel coordinates."
 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;
     HMENU  hMenu;
     short   xScreen, yScreen;


     if (!hPrevInstance)
   {
   wndclass.style           = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
   wndclass.lpfnWndProc    = WndProc;
   wndclass.cbClsExtra     = 0;
   wndclass.cbWndExtra     = 0;
   wndclass.hInstance      = hInstance;
   wndclass.hIcon           = NULL;
    wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = szAppName;
   wndclass.lpszClassName  = szAppName;

     if (!RegisterClass (&wndclass) )
         return FALSE;
     }

    xScreen = GetSystemMetrics (SM_CXSCREEN);
     yScreen = GetSystemMetrics (SM_CYSCREEN);

     hWnd = CreateWindow (szAppName, "GetPixel",
            WS_OVERLAPPEDWINDOW, xScreen / 7, yScreen / 58,
            xScreen * 3 / 4, yScreen * 49 / 50, NULL, NULL,
            hInstance, NULL);

     hInstMain = hInstance;
     hWndMain  = hWnd;

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

     lpProcEnterPoint    = MakeProcInstance (EnterPointDlgProc, hInstance);
     lpProcNewEnterPoint = MakeProcInstance (NewEnterPointDlgProc,hInstance);


     while (GetMessage (&msg, NULL, 0, 0))
         {
         TranslateMessage (&msg);
         DispatchMessage (&msg);
         }

     DeleteObject (hBitmapHelp);

     return msg.wParam;
 }
 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
    HWND      hWnd;
    unsigned  iMessage;
    WORD      wParam;
    LONG      lParam;
    {
    int           Index;
    HANDLE        hDC;
    HDC           hMemoryDC;
    BITMAP        Bitmap;
   short         foo;

    HMENU         hMenu;
    PAINTSTRUCT   ps;
    POINT         pt;
    static int    xClient, yClient;
    static int    xDevisor, yDevisor, randNum;
    DWORD         Attribute;


    switch (iMessage)
        {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             break;

        case WM_SIZE:
             xClient = LOWORD (lParam);
             yClient = HIWORD (lParam);

             hDC = GetDC(hWnd);

             hMemoryDC = CreateCompatibleDC(hDC);
             hBitmapHelp = LoadBitmap (hInstMain, "BitmapHelp");
             GetObject(hBitmapHelp, 16, (LPSTR) &Bitmap);
             SelectObject(hMemoryDC, hBitmapHelp);
             foo = GetStretchBltMode (hDC);

             SetStretchBltMode(hDC, BLACKONWHITE);
             StretchBlt(hDC, 0, 0, LOWORD (lParam), HIWORD (lParam),
         hMemoryDC, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);

             SetStretchBltMode(hDC, foo);
             DeleteObject (hBitmapHelp);
         DeleteDC(hMemoryDC);
             ReleaseDC(hWnd, hDC);

             break;

        case WM_LBUTTONDOWN:
             pt = MAKEPOINT (lParam) ;
             hDC = GetDC (hWnd);
             Attribute = GetPixel (hDC, pt.x, pt.y);
             sprintf (szOutputBuffer1, "The Point [%i, %i]", pt.x, pt.y);
             sprintf (szOutputBuffer2, "Has Attribute %x", Attribute);
             MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1,MB_OK);
             ReleaseDC(hWnd, hDC);
             break;


        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
             break;


        case WM_COMMAND:
             switch (wParam) {
                case IDM_RANDOM:
                     pt.x = pt.y = -1;
                     while (((pt.x < 0) || (pt.x > xClient)) || ((pt.y < 0) ||
                             (pt.y > yClient))) {
                        pt.x = (rand () / 47);
                        pt.y = (rand () / 102);
                     }
                     hDC = GetDC (hWnd);
                     Attribute = GetPixel (hDC, pt.x, pt.y);
                     sprintf (szOutputBuffer1, "The Point [%i, %i]", pt.x, pt.
                     sprintf (szOutputBuffer2, "Has Attribute %x", Attribute);
                     MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1,MB_OK)
                     ReleaseDC(hWnd, hDC);
                     break;

                case IDM_ENTER:
                     pt.x = pt.y = -1;
                     while (((pt.x < 0) || (pt.x > xClient)) || ((pt.y < 0) ||
                             (pt.y > yClient))) {
                       DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                              lpProcEnterPoint);
                       pt.x = atoi (szXValue);
                       pt.y = atoi (szYValue);
                     }
                     hDC = GetDC (hWnd);
                     Attribute = GetPixel (hDC, pt.x, pt.y);
                     sprintf (szOutputBuffer1, "The Point [%i, %i]", pt.x, pt.
                     sprintf (szOutputBuffer2, "Has Attribute %x", Attribute);
                     MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1,MB_OK)
                     ReleaseDC(hWnd, hDC);
                     break;

                case IDM_HELP:
                     ProcessMessage (hWnd, 2);
                     break;

            }
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }

 /****************************************************************************

 BOOL FAR PASCAL EnterPointDlgProc (hDlg, iMessage, wParam, lParam)
 HWND hDlg;
 unsigned iMessage;
 WORD wParam;
 LONG lParam;
 {
      int Index;
      char szChange [10];
      long lReturn;

      switch (iMessage) {
      case WM_INITDIALOG:
        SendDlgItemMessage (hDlg, IDD_X, EM_LIMITTEXT,
                            (WORD)40, 0L);
        SendDlgItemMessage (hDlg, IDD_Y, EM_LIMITTEXT,
                            (WORD)40, 0L);

        hX = GetDlgItem (hDlg, IDD_X);
          lpProcOldX = (FARPROC) GetWindowLong (hX, GWL_WNDPROC);
          SetWindowLong (hX, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hX, EM_SETSEL, 0, MAKELONG (0,32767));
        hY = GetDlgItem (hDlg, IDD_Y);
          lpProcOldY = (FARPROC) GetWindowLong (hY, GWL_WNDPROC);
          SetWindowLong (hY, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hY, EM_SETSEL, 0, MAKELONG (0,32767));
        hOK2 = GetDlgItem (hDlg, IDOK);

        return TRUE;
        break;

      case WM_COMMAND:
        switch (wParam) {
          case IDD_X:
               break;

          case IDD_Y:
               break;

          case IDOK:
               GetDlgItemText (hDlg, IDD_X, szXValue, 10) ;
               GetDlgItemText (hDlg, IDD_Y, szYValue, 10) ;
               EndDialog (hDlg, TRUE);
               break;

          default:
               return FALSE;
       }
     default:
       return FALSE;
   }
   return TRUE;
 }

 /****************************************************************************

 BOOL FAR PASCAL NewEnterPointDlgProc  (hWnd, iMessage, wParam, lParam)
      HWND     hWnd;
      unsigned iMessage;
      WORD     wParam;
      LONG     lParam;
 {
      switch (iMessage) {
        case WM_GETDLGCODE:
             return (DLGC_WANTALLKEYS);

        case WM_CHAR:
             if ((wParam == VK_TAB) || (wParam == VK_RETURN)) {
                 SendMessage (hWndMain, WM_USER, 0, 0L);
                 SetFocus (FindNextWindow (hWnd));
                 return TRUE;
             }
             else {
               if (hWnd == hX)
                 return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                         iMessage, wParam, lParam));
               if (hWnd == hY)
                 return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                         iMessage, wParam, lParam));
             }
             break;

        default:
          if (hWnd == hX)
             return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                     iMessage, wParam, lParam));
          if (hWnd == hY)
             return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                     iMessage, wParam, lParam));
      }
 }

 /****************************************************************************

 HWND FindNextWindow (hWnd)
      HWND   hWnd;
 {
      if (hWnd == hX)      return hY;
      if (hWnd == hY)      return hOK2;
      return NULL;
 }



 GETPROFI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GETPROFI.C

 #include <windows.h>
 #include <stdio.h>

  BUFSIZE 80 /* Output Buffer Size */

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
    char szOutBuf[BUFSIZE];              /* Output Buffer                  */
    int iReturn;                         /* WIN.INI DoubleClickSpeed Value */

    iReturn = GetProfileInt((LPSTR)"windows",          /* Application Name */
                            (LPSTR)"DoubleClickSpeed", /* Key Name         */
                            (int)-999);                /* Default Value    */
    if (iReturn == -999) {  /* If the default was returned, say so */
       sprintf(szOutBuf, "%s%d",
               "The Default Value was Returned: ",
               iReturn);
       MessageBox(GetFocus(), (LPSTR)szOutBuf,
                  (LPSTR)"GetProfileInt() - Default!",
                  MB_OK | MB_ICONEXCLAMATION);
       }
    else {  /* Otherwise, display the speed in a message box */
       sprintf(szOutBuf, "%s%d",
               "The DoubleClickSpeed Returned is: ",
               iReturn);
       MessageBox(GetFocus(), (LPSTR)szOutBuf,
                  (LPSTR)"GetProfileInt()", MB_OK);
       }
    return FALSE;
 }


 GETPROFS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GETPROFS.C

 /*
  * This program demonstrates the GetProfileString() function. It attempts
  * to obtain the string corresponding to the following:
  *
  *   [windows]
  *   spooler=<string>
  *
  */

 #include <windows.h>
 #include <stdio.h>

 #define BUFSIZE 10

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
    int iCopied;             /* Number of Characters Copied from WIN.INI */
    char szOutBuf[BUFSIZE];  /* Output Buffer to Receive WIN.INI info.   */

    iCopied = GetProfileString((LPSTR)"windows",     /* Application Name */
                               (LPSTR)"spooler",     /* Key Name         */
                               (LPSTR)"Default!",    /* Default String   */
                               (LPSTR)szOutBuf,      /* Output Buffer    */
                               (int)BUFSIZE);        /* Number of Chars. */
    if (iCopied == 0) /* If No Chars. Copied, Issue Error. */
       MessageBox(GetFocus(), (LPSTR)"Error Getting Profile String!",
                  (LPSTR)"GetProfileString() Error!",
                  MB_OK | MB_ICONEXCLAMATION);
    else /* Otherwise, print out the results. */
       MessageBox(GetFocus(), (LPSTR)szOutBuf,
                  (LPSTR)"GetProfileString() - spooler =",
                  MB_OK);
    return FALSE;
 }


 GETROP2.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETROP2.C

 /*

 Windows Version 2.03 function demonstration application

 Function(s) demonstrated in this program: GetROP2

 Compiler version: 5.01


 Description:

 The GetROP2 function returns the current drawing mode.  The drawing mode
 specifies how the pen or interior color and the color already on the
 display surface are combined to yield a new color.  This program
 simply calls GetROP2 and displays the current drawing mode based on
 the function return value.


 Additional Comments:

 Note that the drawing modes define how GDI combines source and destination
 colors when drawing with the current pen.

 ****************************************************************************/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetROP2" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      HDC             hDC;                 /* For the GetROP2 demonstration */
      short           iROP2;               /* For the GetROP2 demonstration */

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "GetROP2",                  /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

 /***************************************************************************/
 /* Begin the GetROP2 demonstration */

      hDC = GetDC (hWnd);
      iROP2 = GetROP2 (hDC);                /* Get the current drawing mode */

      switch (iROP2)
         {
         case R2_BLACK:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_BLACK.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOTMERGEPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_NOTMERGEPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MASKNOTPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MASKNOTPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOTCOPYPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_NOTCOPYPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MASKPENNOT:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MASKPENNOT.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOT:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_NOT .",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_XORPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_XORPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOTMASKPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)" The current drawing mode returned by GetROP2
 is R2_NOTMASKPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MASKPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MASKPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOTXORPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_NOTXORPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_NOP:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_NOP.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MERGENOTPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MERGENOTPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_COPYPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_COPYPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MERGEPENNOT:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MERGEPENNOT.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_MERGEPEN:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_MERGEPEN.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         case R2_WHITE:
            {
            MessageBox (hWnd,
                        (LPSTR)"The current drawing mode returned by GetROP2 \
 is R2_WHITE.",
                        (LPSTR)"GetROP2",
                        MB_OK
                       );
            break;
            }
         default:
            MessageBox (hWnd,
                        (LPSTR)"Something is wrong.  GetROP2 is supposed to \
 return the current drawing mode but instead returns an unknown value.",
                        (LPSTR)"GetROP2",
                        NULL
                       );
            break;
         } /* end switch */

      ReleaseDC (hWnd, hDC);

 /* End the GetROP2 demonstration */
 /***************************************************************************/

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {

  switch(iMessage)
  {
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }

  return (0L);
 }


 GETSCPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\GETSCPOS.C

 /*
  *
  *  GetScrollPos
  *
  *  This program demonstrates the use of the function GetScrollPos.
  *  It retrieves the current position of a scroll bar elevator.
  *
  */

 #include "windows.h"
 #include "stdio.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Getscpos";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;                /* Handle to the parent window    */
     WORD  nPos;                /* The position of the elevator   */
     char  szBuffer[35];        /* string buffer for the message
                                 * box                            */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Getscpos",
                         (LPSTR)"Getting Scroll Position",
                         WS_OVERLAPPEDWINDOW|WS_VSCROLL,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Setting up the vertical and horizontal scroll bars range */
     SetScrollRange (hWnd, SB_VERT, 1, 10, (BOOL)TRUE);

     /* initial position on a vertical scroll bar */
     SetScrollPos (hWnd, SB_VERT, 2, (BOOL)TRUE);
     nPos = GetScrollPos (hWnd, SB_VERT);
     sprintf (szBuffer, "The elevator is currently at %d", nPos);
     MessageBox (hWnd, (LPSTR)szBuffer, (LPSTR)"Vertical", MB_OK);

     /* moved to a new location */
     SetScrollPos (hWnd, SB_VERT, 9, (BOOL)TRUE);
     nPos = GetScrollPos (hWnd, SB_VERT);
     sprintf (szBuffer, "The elevator is currently at %d", nPos);
     MessageBox (hWnd, (LPSTR)szBuffer, (LPSTR)"Vertical", MB_OK);

     return 0;
 }


 GETSCRNG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\GETSCRNG.C

 /*
  *
  *  GetScrollRange
  *
  *  This program demonstrates the use of the function GetScrollRange.
  *  It retrieves the current minimum and maximum scroll bar range
  *  for the given scroll bar.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"
 #include "stdio.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Getscrng";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;                /* Handle to the parent window    */
     short nMinPos, nMaxPos;    /* The range of the scroll bar    */
     char  szBuffer[50];        /* string buffer for the message
                                 * box                            */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Getscrng",
                         (LPSTR)"GetScrollRange",
                         WS_OVERLAPPEDWINDOW|WS_VSCROLL,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Setting up the vertical scroll bar range and use GETSCROLLRANGE
      * to retrieve the range
      */
     SetScrollRange (hWnd, SB_VERT, 1, 10, (BOOL)TRUE);
     GetScrollRange (hWnd, SB_VERT, (LPINT) &nMinPos, (LPINT) &nMaxPos);
     sprintf (szBuffer, "The range of the scroll bar is between %d and %d",
              nMinPos, nMaxPos);
     MessageBox (hWnd, (LPSTR)szBuffer, (LPSTR)"GetScrollRange", MB_OK);

     return 0;
 }



 GETSTOCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GETSTOCK.C

 /*
  *  GetStockObject
  *
  *  This function demonstrates the use of the GetStockObject function.  It wi
  *  create a window using the CreateWindow function, show the window using
  *  the ShowWindow command and procede to draw a triangle in the window in
  *  the MM_ANISOTROPIC mapping mode.  It will use the GetStockObject function
  *  to get the handle to a new brush.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 /* Forward Declarations  */

 BOOL FAR PASCAL InitGetStockObject ( HANDLE , HANDLE , int );
 long FAR PASCAL GetStockObjectWindowProc ( HANDLE , unsigned , WORD , LONG );

 /*
  *  MAIN PROCEDURE
  */

 int PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , nCmdShow )

 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int nCmdShow;
   {
   MSG  msg;          /*  Temp buffer to hold message  */

   InitGetStockObject (hInstance, hPrevInstance, nCmdShow );  /*  Init Routine

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);     /*  Give Your windowproc the  */
     }              /*  message        */

   exit(msg.wParam);
   }

 BOOL FAR PASCAL InitGetStockObject (hInstance , hPrevInstance , nCmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int nCmdShow;

   {
   WNDCLASS  wcGetStockObjectClass;
   HWND  hWnd;

   wcGetStockObjectClass.lpszClassName = (LPSTR) "GetStockObject";
   wcGetStockObjectClass.hInstance     = hInstance;
   wcGetStockObjectClass.lpfnWndProc   = GetStockObjectWindowProc;
   wcGetStockObjectClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
   wcGetStockObjectClass.hIcon        = NULL;
   wcGetStockObjectClass.lpszMenuName  = (LPSTR) NULL;
   wcGetStockObjectClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcGetStockObjectClass.style        = CS_HREDRAW | CS_VREDRAW;
   wcGetStockObjectClass.cbClsExtra    = 0;
   wcGetStockObjectClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) &wcGetStockObjectClass);

   hWnd = CreateWindow((LPSTR) "GetStockObject",   /*  Window class name
           (LPSTR) "GetStockObject",   /*  Window title        */
           WS_OVERLAPPEDWINDOW,    /*  Type of window        */
           CW_USEDEFAULT,      /*  default x pos        */
           CW_USEDEFAULT,      /*  default y pos        */
           CW_USEDEFAULT,      /*  default change in x pos */
           CW_USEDEFAULT,      /*  default change in y pos */
           (HWND)NULL,      /*  No parent for this wind */
           (HMENU)NULL,      /*  Use the Class menu      */
           (HANDLE)hInstance,    /*  Who created this window */
           (LPSTR)NULL      /*  No params. to pass on.  */
          );

   ShowWindow (hWnd , nCmdShow);   /*  Display this window on the screen
            *  nCmdShow is passed in by WinMain, and
            *  should only be used with ShowWindow
            *  once during a program.  Any further
            *  calls to ShowWindow will need to have
            *  certain values.  See entry in manual
            *  for ShowWindow for further details
            */

   UpdateWindow (hWnd);     /*  Cause a paint message    */

   return TRUE;
   }

 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long FAR PASCAL GetStockObjectWindowProc (hWnd , message , wParam , lParam)

 HWND      hWnd;        /*  Handle of the window  */
 unsigned    message;        /*  Message type    */
 WORD      wParam;        /*  Message 16-bit param  */
 LONG      lParam;        /*  Message 32-bit param  */
   {
   switch (message)        /*  Check the message type  */
     {
     case WM_PAINT:        /*  Process the Paint  */
   PaintGetStockObjectWindow (hWnd); /*  message          */
   break;

     case WM_DESTROY:        /*  If close requested  */
   PostQuitMessage(0);      /*    send yourself a quit  */
   break;          /*    message    */

     default:
   return( DefWindowProc( hWnd , message , wParam , lParam ) );
   break;
     }
   return( 0L );
   }

 /*
  *  THE PAINT PROCEDURE
  */

 PaintGetStockObjectWindow (hWnd)

 HWND  hWnd;             /*  Handle of the window  */
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE  hOldBrush , hBrush;        /*  For loading new brushes  */
   RECT    rRect;            /*  Will hold the client     */
                 /*  Rectangle       */

   BeginPaint (hWnd , (LPPAINTSTRUCT) &ps);    /*  Prepare the client area  */
   hDC = ps.hdc;             /*  Get the Display Context  */

   hBrush    = GetStockObject ( GRAY_BRUSH );  /*  Get a gray brush     */

   hOldBrush = SelectObject ( hDC , hBrush );  /*  Select the new brush     */

   lpTriangle[0].x = 150;    /*  The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode ( hDC , MM_ANISOTROPIC );   /*  Set the mapping mode        */

   SetWindowExt ( hDC , 300 , 300 );   /*  Set the extent of the drawing
             *  area.  This is the area that
             *  holds graphics that you create
             *  with GDI functions.  Do not
             *  confuse this function with
             *  the actual window.  The
             *  SetViewportExt sets the
             *  extent of the area to be mapped
             *  to which is the actual window
             */

   GetClientRect ( hWnd , (LPRECT) &rRect );
            /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt ( hDC , rRect.right , rRect.bottom );
            /*  Set the Extent of the viewport   */

   Polygon ( hDC , lpTriangle , 3 );   /*  Draw the triangle          */

   ValidateRect (hWnd , (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) &ps );

   SelectObject( hDC , hOldBrush );   /*  Replace the old brush  */
   return TRUE;
   }


 GETTEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\GETTEXT.C

 /*
  *   GetWindowText
  *
  *   This program demonstrates the use of the GetWindowText function. The
  *   GetWindowText function copies the given window's caption bar (if one
  *   exists) into the second parameter. GetWindowText returns an integer
  *   specifying the length of the caption. If GetWindowText returns 0, then
  *   there is no caption for the given window.
  *
  */

 #include "windows.h"
  <stdio.h>     /* required for sprintf */

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     int x;           /* return value from GetWindowText  */
     char buffer[40];         /* buffer that GetWindowText places text */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* get caption bar text if it exists */
     x=GetWindowText(hWnd,buffer,40);
     /* if there is a caption */
     if (x>0)
       /* output the caption    */
       MessageBox(hWnd,(LPSTR)buffer,
          (LPSTR)"THE CAPTION BAR SAYS:",MB_OK);
     else
       /* output "There is no Title Bar */
       MessageBox(hWnd,(LPSTR)NULL,
          (LPSTR)"There is no Title Bar",MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETTIMER.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TIME\GETTIMER.C

 /*

 Function(s) demonstrated in this program: GetTimerResolution

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns a handle to the display context.

 Additional Comments:  This function is undocumented in the SDK manuals.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetTimeR.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetTimerResolution Windows function.",

 "Help Message",
 "     This program uses the GetTimerResolution Windows\n\
 function to get the timer resolution.  Use the menu\n\
 to invoke this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetTimeR" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetTimerResolution",       /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  DWORD       nTimerResolution;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETTIMER:
                nTimerResolution = GetTimerResolution ();
                sprintf (szOutputBuffer1, "Timer Resolution = %i", nTimerResol
                MessageBox (hWnd, szOutputBuffer1, "GetTimerResolution", MB_OK
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETVWORG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\GETVWORG.C

 /*
  *
  * GetViewportOrg
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetViewportOrg function.
  *  Two message boxes are created which display the x and y coordinates
  *  of the viewport origin respectively.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;            /* Handle to the Display Context. */
   unsigned int xOrg;  /* X coordinate of the origin.    */
   unsigned int yOrg;  /* Y coordinate of the origin.    */
   long ptOrigin;      /* Long pointer to the origin.    */
   char szbuf[19];     /* Output buffer.                 */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getvworg";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getvworg",
            (LPSTR) "GetViewportOrg",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    hDC = GetDC(hWnd);

    ptOrigin = GetViewportOrg(hDC);      /* Get the viewport origin.  */

    xOrg = LOWORD(ptOrigin);             /* Isolate the X coordinate. */
    yOrg = HIWORD(ptOrigin);             /* Isolate the Y coordinate. */

    sprintf(szbuf,                       /* Place the X coordinate in */
            "%s%d",                      /*  the output buffer along  */
            "The x Origin is ",          /*  with some explanatory    */
            xOrg);                       /*  text.                    */
    MessageBox(NULL,                     /* Display the information   */
               (LPSTR)szbuf,             /*  in a message box.        */
               (LPSTR)"GetViewportOrg",
               MB_OK);

    sprintf(szbuf,                       /* Place the Y origin in the */
            "%s%d",                      /*  output buffer along with */
            "The y Origin is ",          /*  some text.               */
            yOrg);
    MessageBox(NULL,                     /* Output the information in */
               (LPSTR)szbuf,             /*  another message box.     */
               (LPSTR)"GetViewportOrg",
               MB_OK);

 } /* WinMain */


 GETWIND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWIND.C

 /*

 Function(s) demonstrated in this program: GetWindow

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns a handle to the next or previous Window
    in the Window Manager list.  If no match is found a NULL handle is
   returned.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GetWind.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetWindow Windows function.",

 "Help Message",
 "     This program uses the GetWindow Windows function\n\
 to get a handle to the next window in the Window\n\
 manager handle list.  This handle is then displayed\n\
 in a message box.  The window corresponding to that\n\
 handle is then iconized.  Use the menu to invoke\n\
 this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetWind" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetWindow",               /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HWND        hNextWindow;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETWINDOW:
                hNextWindow = GetWindow (hWnd, GW_HWNDNEXT);
                sprintf (szOutputBuffer1,
                       "The Handle to the Next Window is %x", hNextWindow);
                MessageBox (hWnd, szOutputBuffer1, "GetWindow", MB_OK);
                if (!IsIconic (hNextWindow))
                   ShowWindow (hNextWindow, SW_SHOWMINIMIZED);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GETWINDC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWINDC.C

 /*
  * GetWindowDC
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetWinDC function.
  *  If the function call is successful, a message box is created which
  *  reflects success.  Otherwise, failure is reported via message box.
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG  msg;
   HDC  hDC;     /* Handle to the Display Context. */
   BOOL bResult; /* Result from using the DC.      */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getwindc";  /* Unique class name. */
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);
      }

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getwindc", /* Create the window.        */
            (LPSTR) "GetWindowDC",        /* Title: GetWindowDC.       */
            WS_OVERLAPPEDWINDOW,          /* Set to overlapped window. */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    if ((hDC = GetWindowDC(hWnd)) != NULL)     /* If successful at getting */
       MessageBox(GetFocus(),                  /*  the DC, send success    */
      (LPSTR)"Got The Window DC",            /*  message via message    */
      (LPSTR)"GetWindowDC",                  /*  box.                 */
      MB_OK);
    else                                     /* Otherwise,               */
       MessageBox(GetFocus(),                  /*  send the failure        */
      (LPSTR)"Do Not Have the DC",           /*  message via message    */
      (LPSTR)"GetWindowDC",                  /*  box.                 */
      MB_OK);

    bResult = Rectangle(hDC, 100, 100, 200, 200);

    if (bResult != NULL)
       MessageBox(GetFocus(), (LPSTR)"Used DC Successfully",
                  (LPSTR)"Rectangle()", MB_OK);
    else
       MessageBox(GetFocus(), (LPSTR)"Error Using DC",
                  (LPSTR)"Rectangle()", MB_OK);

    ReleaseDC(hWnd, hDC);

 } /* WinMain */


 GETWINWD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWINWD.C

 /*
  *   GetWindowWord
  *
  *   This program demonstrates the use of the GetWindowWord function.
  *   GetWindowWord returns information about the window identified by
  *   the first parameter. The information it returns is specified by the
  *   second parameter. In this sample application, GetWindowWord was
  *   called in WinMain and passed "hWnd" and "GWW_HINSTANCE," telling it
  *   to return the instance handle of the module owning "hWnd."
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     HDC hDC;      /* handle to display context */
     HANDLE ourhInstance;  /* return value from GetWindowWord */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"GetWindowWord",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     hDC = GetDC(hWnd);    /** get a display context for hWnd **/

     TextOut(hDC,
       20,
       5,
   (LPSTR)"I will now call GetWindowWord and pass it 'hWnd' and 'GWW_HINSTANCE
   (short)68);

     TextOut(hDC,
       20,
       15,
 (LPSTR)"telling it to retrieve the instance handle of the module owning the",
   (short)67);

     TextOut(hDC,
       20,
       25,
   (LPSTR)"window associated with hWnd. GetWindowWord should return 'hInstance
   (short)69);

   MessageBox(hWnd,(LPSTR)"  OKAY",(LPSTR)" ",MB_OK);

 /**   call GetWindowWord, tell it to retrieve the instance handle  **/
 /**   of the module owning the window associated with hWnd     **/
   ourhInstance = GetWindowWord(hWnd,GWW_HINSTANCE);

 /**   clear screen **/
   InvalidateRect(hWnd,(LPRECT)NULL,(BOOL)TRUE);
   UpdateWindow(hWnd);

 /**  if GetWindowWord correctly returned the instance handle **/
 /**  of the  module owning the window associated with hWnd.. **/
   if (ourhInstance = hInstance)
       MessageBox(hWnd,
     (LPSTR)"instance handle of the module owning hWnd.",
     (LPSTR)"GetWindowWord correctly retrieved the...",
     MB_OK);
     else
       MessageBox(hWnd,
     (LPSTR)"instance handle of the module owning hWnd.",
     (LPSTR)"GetWindowWord DID NOT correctly retrieve the...",
     MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GETWNEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWNEXT.C

 /*
  * GetWindowExt()
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetWindowExt function.
  *  Two message boxes are created which display the coordinates of the
  *  window extentions.
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG   msg;
   HDC   hDC;             /* Handle to the Display Context.  */
   WORD  xExt;            /* X extent.                       */
   WORD  yExt;            /* Y extent.                       */
   DWORD dwExtent;        /* Long pointer to the extent.     */
   char szbuf[50];        /* Output buffer, zero terminated. */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getwnext"; /* Unique class name. */
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getwnext", /* Create the Window.        */
            (LPSTR) "GetWindowExt",       /* Title: GetWindowExt.      */
            WS_OVERLAPPEDWINDOW,          /* Set to overlapped window. */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            CW_USEDEFAULT,                /* Use default coordinates.  */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);
    UpdateWindow(hWnd);

    hDC = GetDC(hWnd);               /* Get the handle to the DC. */
    dwExtent = GetWindowExt(hDC);    /* Get the window extents.   */

    xExt = LOWORD(dwExtent);         /* Isolate the X extent.     */
    yExt = HIWORD(dwExtent);         /* Isolate the Y extent.     */

    sprintf(szbuf,                   /* Place X extent, with      */
            "%s%hu",                 /*  message, into the output */
            "The Original x Extent is ",  /*  buffer for display  */
            xExt);                   /* in a message box.         */
    MessageBox(GetFocus(),           /* Output the X extent in a  */
               (LPSTR)szbuf,         /*  message box.             */
               (LPSTR)"GetWindowExt() - MM_TEXT",
               MB_OK);

    sprintf(szbuf,                   /* Place Y extent, with      */
            "%s%hu",                 /*  message, into the output */
            "The Original y Extent is ", /*  buffer for display   */
            yExt);                   /* in a message box.         */
    MessageBox(GetFocus(),           /* Output the Y extent in a  */
               (LPSTR)szbuf,         /*  message box.             */
               (LPSTR)"GetWindowExt() - MM_TEXT",
               MB_OK);

    MessageBox(GetFocus(), (LPSTR)"Settting Extents to (2,4)",
               (LPSTR)"SetWindowExt() - MM_ISOTROPIC", MB_OK);
    SetMapMode(hDC, MM_ISOTROPIC);   /* Need this or SetWindowExt */
    SetWindowExt(hDC, 2, 4);         /* will be ignored.          */

    dwExtent = GetWindowExt(hDC);    /* Get the window extents.   */

    xExt = LOWORD(dwExtent);         /* Isolate the X extent.     */
    yExt = HIWORD(dwExtent);         /* Isolate the Y extent.     */

    sprintf(szbuf,                   /* Place X extent, with      */
            "%s%hu",                 /*  message, into the output */
            "The New x Extent is ",  /*  buffer for display       */
            xExt);                   /* in a message box.         */
    MessageBox(GetFocus(),           /* Output the X extent in a  */
               (LPSTR)szbuf,         /*  message box.             */
               (LPSTR)"GetWindowExt() - MM_ISOTROPIC",
               MB_OK);

    sprintf(szbuf,                   /* Place Y extent, with      */
            "%s%hu",                 /*  message, into the output */
            "The New y Extent is ",  /*  buffer for display       */
            yExt);                   /* in a message box.         */
    MessageBox(GetFocus(),           /* Output the Y extent in a  */
               (LPSTR)szbuf,         /*  message box.             */
               (LPSTR)"GetWindowExt() - MM_ISOTROPIC",
               MB_OK);

    ReleaseDC(hWnd, hDC);            /* Release the DC.           */

 } /* WinMain */


 GETWNLNG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWNLNG.C

 /*
  * GetWindowLong
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetWindowLong function.
  *  If the function call is successful, two message boxes are created which
  *  show if the window is tiled and the pointer to the window procedure.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;         /* Handle to the Display Context.       */
   LONG lLong;      /* LONG returned by GetWindowLong.       */
   char szbuf[80];  /* String buffer used in Message Boxes. */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getwnlng";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor      = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style        = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getwnlng",
            (LPSTR) "GetWindowLong",
            WS_OVERLAPPEDWINDOW,            /* Use overlapped window.   */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    /* Get the style of the Window */

    lLong = GetWindowLong(hWnd, GWL_STYLE);

    /*  If the Window is tiled, say so; otherwise, report that it is not */

    if ((lLong & WS_OVERLAPPEDWINDOW) == WS_OVERLAPPEDWINDOW)
    {  sprintf(szbuf,"%s","The Window has the Overlapped Style!");
       MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"GWL_STYLE", MB_OK);
    }
    else
    {  sprintf(szbuf, "%s", "The Window is not Overlapped!!!");
       MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"GWL_STYLE", MB_OK);
    }

    /*  Now, get the pointer to the function's window procedure.         */

    lLong = GetWindowLong(hWnd, GWL_WNDPROC);

    /*  Print out the address of the window procedure in a message box.  */

    sprintf(szbuf,"%s%lx","The Pointer to the Window Procedure is ",lLong);
    MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"GWL_WNDPROC", MB_OK);

 } /* WinMain */


 GETWNORG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GETWNORG.C

 /*
  * GetWindowOrg
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetWindowOrg function.
  *  Two message boxes are created which display the x and y coordinates
  *  respectively.  The x and y values here are the default values.
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;            /* Handle to the Display Context. */
   unsigned int xOrg;  /* X origin.                      */
   unsigned int yOrg;  /* Y origin.                      */
   long ptOrigin;      /* Pointer to the origin.         */
   char szbuf[50];     /* Output buffer.                 */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getwnorg";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style        = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getwnorg",
            (LPSTR) "GetWindowOrg",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);
    UpdateWindow(hWnd);

    hDC = GetDC(hWnd);                /* Get the handle to the DC.     */
    ptOrigin = GetWindowOrg(hDC);     /* Get the origin of the window. */
    ReleaseDC(hWnd, hDC);             /* Release the DC.               */
    xOrg = LOWORD(ptOrigin);          /* Isolate the x coordinate.     */
    yOrg = HIWORD(ptOrigin);          /* Isolate the y coordinate.     */

       /* Display the X coordinate in a message box. */

    sprintf(szbuf,"%s%d","The Original x Origin is ",xOrg);
    MessageBox(GetFocus(), (LPSTR)szbuf, (LPSTR)"GetWindowOrg", MB_OK);

       /* Display the Y coordinate in a message box. */

    sprintf(szbuf,"%s%d","The Original y Origin is ",yOrg);
    MessageBox(GetFocus(), (LPSTR)szbuf, (LPSTR)"GetWindowOrg", MB_OK);

    MessageBox(GetFocus(), (LPSTR)"Setting a New Origin at (5,5)",
               (LPSTR)"SetWindowOrg", MB_OK);

       /* Set a new origin and get it too.           */
    SetWindowOrg(hDC, 5, 5);          /* Set new origin of the window. */
    ptOrigin = GetWindowOrg(hDC);     /* Get new origin of the window. */
    xOrg = LOWORD(ptOrigin);          /* Isolate the x coordinate.     */
    yOrg = HIWORD(ptOrigin);          /* Isolate the y coordinate.     */

       /* Display the X coordinate in a message box. */

    sprintf(szbuf,"%s%d","The New x Origin is ",xOrg);
    MessageBox(GetFocus(), (LPSTR)szbuf, (LPSTR)"GetWindowOrg", MB_OK);

       /* Display the Y coordinate in a message box. */

    sprintf(szbuf,"%s%d","The New y Origin is ",yOrg);
    MessageBox(GetFocus(), (LPSTR)szbuf, (LPSTR)"GetWindowOrg", MB_OK);

 } /* WinMain */


 GETWNRCT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\GETWNRCT.C

 /*
  *
  * GetWindowRect
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetWindowRect function.
  *  If the function call is successful, message boxes are created which
  *  display the rectangle coordinates.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   RECT *rect;         /* Pointer to Window Rectangle. */
   char szbuf[31];       /* Buffer for Message Box.      */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"getwnrct";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "getwnrct",
            (LPSTR) "GetWindowRect",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    GetWindowRect(hWnd, (LPRECT)rect);  /* Get the Window Rectangle.    */

    /* Report the top left and the bottom right of the window rectangle */
    /* in separate message boxes.                                     */

    sprintf(szbuf,"%s%d%s%d%s","The top left is (", rect->top,
      ",", rect->left, ").");
    MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"GetWindowRect", MB_OK);

    sprintf(szbuf,"%s%d%s%d%s","The bottom right is (", rect->bottom,
      ",", rect->right, ").");
    MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"GetWindowRect", MB_OK);

 } /* WinMain */

 /* WINDOWPROC */


 GFOCUS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GFOCUS.C

 /*

 Function(s) demonstrated in this program: GetFocus

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function returns a handle to the Window which currently
    has the input focus.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "gFocus.h"


 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the GetFocus Windows function.",

 "Help Message",
 "     This program uses the GetFocus Windows function\n\
 to get a handle to the Window which has the input\n\
 focus.  This handle is then displayed in a message\n\
 box.  Use the menu to invoke this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "gFocus" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GetDC",                    /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HWND        hWndFocus;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GETFOCUS:
                hWndFocus = GetFocus ();
                sprintf (szOutputBuffer1,
                         "The Handle to the Focus Window is %x", hWndFocus);
                MessageBox (hWnd, szOutputBuffer1, "GetFocus", MB_OK);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GINSTAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GINSTAT.C

 /*
  *
  *  GetInputState
  *
  *  This program demonstrates the use of the function GetInputState.
  *  This function determines whether there are mouse, keyboard, or timer
  *  events in the system queue that require processing.
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   BOOL bState;

   MessageBox (NULL, (LPSTR)"Getting input state", (LPSTR)"GetInputState",
      MB_OK);

   bState = GetInputState ();

   if ( bState != 0 )
      MessageBox (NULL, (LPSTR)"No Important Messages on the Queue", (LPSTR)"G
         MB_OK);
   else
      MessageBox (NULL, (LPSTR)"Important Messages are Waiting",
         (LPSTR)"GetInputState", MB_OK|MB_ICONEXCLAMATION);

   return 0;
 }


 GINSTDAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GINSTDAT.C

 /*
  *
  *  GetInstanceData
  *
  *  This program demonstrates the use of the function GetInstanceData.
  *  This function copies data from a previous intance of an application
  *  into the data area of the current instance.
  *
  *  Other references: numerous apps. with SDK
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 LPSTR far PASCAL lstrcpy( LPSTR, LPSTR );

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int nBytes = 0;
   char szAppName[25];
   char szFuncName[25];
   char szBuffer[80];

   lstrcpy ( (LPSTR) szAppName, (LPSTR) "ginstdat" );

   lstrcpy ( (LPSTR) szFuncName, (LPSTR) "GetIntanceData" );

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) szAppName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }
   else
      {
      MessageBox (NULL, (LPSTR)"Getting instance data",
        (LPSTR)szFuncName, MB_OK );

      nBytes = GetInstanceData( hPrevInstance, (PSTR)szAppName, 25 );

      sprintf ( szBuffer, "%s%d", "The number of bytes copied is ", nBytes );

      MessageBox ( NULL, (LPSTR)szBuffer, (LPSTR)szFuncName, MB_OK );
      }

   hWnd = CreateWindow ( ( LPSTR ) szAppName, ( LPSTR ) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );

   if ( nBytes == 0 )
   MessageBox ( NULL, (LPSTR)"Start another instance before \npushing ok",
       (LPSTR)szFuncName, MB_OK );

   return 0;
 }


 GKEYBSTA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GKEYBSTA.C

 /*
  *  GetKeyboardState
  *
  *  This program demonstrates the use of the function GetKeyboardState.
  *  This function copies the status of the 256 virtual-keyboard keys to the
  *  buffer specified by the parameter.
  *
  */

 #include <windows.h>

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFuncName[] = "GetKeyboardState";
   char rgcKeyState[256];
   char szOutputBuffer1 [500];
   int ncount, I;

   MessageBox(GetFocus(), (LPSTR)"Getting the state of the keyboard",
              (LPSTR)szFuncName, MB_OK);

   (void)GetKeyboardState((LPSTR)rgcKeyState);

   if (rgcKeyState [VK_F1] & 0x80)
      MessageBox(GetFocus(), (LPSTR)"The F1 key is Down",
                 (LPSTR)szFuncName, MB_OK);
   else
      MessageBox(GetFocus (), (LPSTR)"The F1 Key is Up",
                 (LPSTR)szFuncName, MB_OK);

   rgcKeyState [VK_F1] = 0x80;

   MessageBox (GetFocus (),(LPSTR)"The F1 key has been set to the down state."
               (LPSTR)"About to use SetKeyboardState.", MB_OK);

   SetKeyboardState (rgcKeyState);
   GetKeyboardState (rgcKeyState);

   if (rgcKeyState [VK_F1] & 0x80)
      MessageBox(GetFocus(), (LPSTR)"The F1 key has been set successfully",
                 (LPSTR)"The F1 key is Down", MB_OK);
   else
      MessageBox(GetFocus(), (LPSTR)"The F1 was not set successfully",
                 (LPSTR)"The F1 Key is Up", MB_OK);
   return 0;
 }



 GKEYSTAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GKEYSTAT.C

 /*
  *
  *  GetKeyState
  *
  *  This program demonstrates the use of the function GetKeyState
  *  This function retrieves the state of the virtual key specified by the
  *  parameter.
  *
  */

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFuncName[] = "GetKeyState";
   int nState;

   MessageBox (NULL, (LPSTR)"Getting the key state of F1", (LPSTR)szFuncName,
      MB_OK);

   nState = GetKeyState ( VK_F1 );

   if ( ( nState & 0x8000 ) != 0x8000 )
      MessageBox (NULL, (LPSTR)"The key F1 is up", (LPSTR)szFuncName, MB_OK);
   else
      MessageBox (NULL, (LPSTR)"The key F1 is down", (LPSTR)szFuncName, MB_OK)

   return 0;
 }


 GLOBALLO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBALLO.C

 /*
  *   GlobalAlloc
  *
  *   This program demonstrates the use of the GlobalAlloc function. The
  *   GlobalAlloc function allocates memory from the Global heap. GlobalAlloc
  *   was called from WinMain in this sample application.
  *
  */

 #include <windows.h>

 int sprintf();

 typedef struct {    /* structure we are going */
     int x;    /* to allocate and lock   */
     int y;
          } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block       */
     lpMyPtr  ThisPtr;    /* Pointer to MYSTRUCT structure   */
     char szBuff[30];    /* buffer for message box       */

 /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(MYSTRUCT));

 /* if memory allocated properly */
     if (hMemBlock != NULL)
   {
   MessageBox(NULL,(LPSTR)"The memory was allocated properly",
       (LPSTR)" ",MB_OK);

   /* lock memory into current address */
   ThisPtr = (lpMyPtr)GlobalLock(hMemBlock);

   /* if lock worked */
   if (ThisPtr != NULL)
       {
       /* use memory from global heap and output results*/
       ThisPtr->x = 4;
       ThisPtr->y = 4;
       ThisPtr->x = ThisPtr->x*ThisPtr->y;
       sprintf(szBuff,"ThisPtr->x * ThisPtr->y = %d",ThisPtr->x);
       MessageBox(NULL,(LPSTR)szBuff,
           (LPSTR)"Info from GlobalAlloc'ed memory",
           MB_OK);
       GlobalUnlock(hMemBlock);  /* unlock block */
       GlobalFree(hMemBlock);  /* free block  */
       }
   else ;
   }
     else
   MessageBox(NULL,(LPSTR)"The memory was not allocated",
       (LPSTR)" ",MB_OK);
     return 0;
 }


 GLOBCMPC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBCMPC.C

 /*
  *   GlobalCompact
  *   globcmpc.c, jeffst, v1.00, 22-Sept-1987
  *
  *   This program demonstrates the use of the GlobalCompact function. The
  *   GlobalCompact function compacts the global heap. GlobalCompact was
  *   called from WinMain in this sample application.
  *
  *   Microsoft Product Support Services
  *   Windows Version 2.0 function demonstration application
  *   Copyright (c) Microsoft 1987
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {
     int x;
     int y;
          } MYSTRUCT;
 typedef MYSTRUCT far *lpMyPtr;

 typedef struct {
     char smallstruct[2];
          } SMALLSTRUCT;
 typedef struct {
     char bigstruct[20000];
          } BIGSTRUCT;

 typedef BIGSTRUCT far *lpBIGPtr;
 typedef SMALLSTRUCT far *lpSMALLPtr;


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE    hMemBlock1;    /* Handle to memory block */
     HANDLE    hMemBlock2;    /* Handle to memory block */
     lpMyPtr    ThisPtr;    /* Pointer to myStruct    */
     lpBIGPtr    HugePtr;
     lpSMALLPtr    MiniPtr;
     char szBuff[50];
     DWORD ContigFreeBytes;

 /* GlobalCompact to ask for FFFF continguous bytes */
     ContigFreeBytes = (DWORD)GlobalCompact((DWORD)-1);
     sprintf(szBuff,"Number of contiguous free bytes before allocation = %lu",
                   ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)" ",MB_OK);

 /* Allocate 2 bytes from global heap */
     hMemBlock1 = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DISCARDABLE
         (long)sizeof(SMALLSTRUCT));
 /* if block allocated properly */
     if (hMemBlock1 != NULL)
   /* lock block into memory */
   MiniPtr = (lpSMALLPtr)GlobalLock(hMemBlock1);

 /* ask for FFFF contiguous free bytes */
     ContigFreeBytes = (DWORD)GlobalCompact((DWORD)-1);
     sprintf(szBuff,"Number of contiguous free bytes = %lu",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After allocating 2 bytes...",MB_OK)

 /* Allocate 50000 bytes from global heap */
     hMemBlock2 = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE |GMEM_DISCARDABLE,
         (long)sizeof(BIGSTRUCT));
 /* if memory allocated properly */
     if (hMemBlock2 != NULL)
   /* lock block into memory */
   HugePtr = (lpBIGPtr)GlobalLock(hMemBlock2);

 /* ask for FFFF contiguous free bytes */
     ContigFreeBytes = (DWORD)GlobalCompact((DWORD)-1);
     sprintf(szBuff,"Number of contiguous free bytes = %lu",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After allocating 50000 bytes...",MB

     GlobalUnlock(hMemBlock2);    /* unlock the blocks */
     GlobalUnlock(hMemBlock1);    /*           */


 /* ask for FFFF contiguous free bytes */
     ContigFreeBytes = (DWORD)GlobalCompact((DWORD)-1);
     sprintf(szBuff,"Number of contiguous free bytes = %lu",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After unlocking 50000 bytes...",MB_


     return 0;
 }


 GLOBCOMP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBCOMP.C

 /*

 Function(s) demonstrated in this program: GlobalCompact

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function compacts global memory.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "GlobComp.h"

 HWND     hWndParent1;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use of the GlobalCompact Windows function.",

 "Help Message",
 "     This program uses the GlobalCompact Windows\n\
 function to compact global memory.  Use the menu\n\
 to invoke this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GlobComp" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "GlobalCompact",            /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  HDC         hDC;
  PAINTSTRUCT ps;
  static int  xClient, yClient;

  DWORD ContigFreeBytes;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_GLOBALCOMPACT:
                ContigFreeBytes = (DWORD)GlobalCompact((DWORD)0);
                sprintf(szOutputBuffer1, "%s%lu",
                  "Number of contiguous free bytes = ",
                  ContigFreeBytes);

                MessageBox(hWnd, szOutputBuffer1, "GlobalCompact", MB_OK);

                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }





 GLOBDISC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBDISC.C

 /*
  *   GlobalDiscard
  *   globdisc.c
  *
  *   This program demonstrates the use of the GlobalDiscard function.
  *   The GlobalDiscard function marks a block of memory for discarding.
  *   After GlobalDiscarding, to check if a block has really been discarded,
  *   try to GlobalLock. If the return value is NULL, then the block has
  *   been discarded.
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {     /* structure we are going */
     char x[50];   /* to allocate and lock  */
     int y;
          } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block       */
     lpMyPtr  ThisPtr;    /* Pointer to myStruct       */
     char szBuff[60];    /* buffer for message box       */
     HANDLE Discarded;    /* return value from GlobalDiscard */

     (DWORD)GlobalCompact((DWORD)-1);

 /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DISCARDABLE,
         (long)sizeof(MYSTRUCT));

 /* if memory allocated properly */
     if (hMemBlock)
   {
   /* lock memory into current address */
   ThisPtr = (lpMyPtr)GlobalLock(hMemBlock);

   /* if lock worked */
   if (ThisPtr != NULL)
       {

         GlobalUnlock(hMemBlock);    /* unlock memory */

    /* mark hMemBlock for discarding */
         GlobalDiscard(hMemBlock);

    /* if GlobalLock works (meaning hMemBlock not discarded) */
       if ( (ThisPtr = (lpMyPtr)GlobalLock(hMemBlock)) != NULL)
     MessageBox(NULL,(LPSTR)"It has not been discarded",
         (LPSTR)" ",MB_OK);
       else
     MessageBox(NULL,(LPSTR)"It HAS been discarded",
         (LPSTR)"Before compaction...",MB_OK);
       GlobalCompact((DWORD)-1);

    /* if GlobalLock works (meaning hMemBlock not discarded) */
       if ((ThisPtr = (lpMyPtr)GlobalLock(hMemBlock)) != NULL)
     MessageBox(NULL,(LPSTR)"it has not been discarded",
         (LPSTR)"After compaction...",MB_OK);
       else
     MessageBox(NULL,(LPSTR)"it HAS been discarded",
         (LPSTR)"After compaction...",MB_OK);
       }
   }
     return 0;
 }


 GLOBFLAG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBFLAG.C

 /*
  *   This program demonstrates the use of the GlobalFlags function. The
  *   GlobalFlags function returns information about the specified block
  *   of memory allocated in the Global heap. GlobalFlags was called from
  *   WinMain in this sample application.
  */

 #include "windows.h"
 #include <stdio.h>

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block */
     char far *lpszMem;   /* Pointer to Double Word in Global Memory. */
     char szBuff[30];     /* buffer for message box */
     BOOL unlocked;       /* return value from GlobalUnlock */
     WORD FlagCall;       /* return value from GlobalFlags */

 /* allocate space in global heap for MOVEABLE and DISDCARDABLE memory */
     MessageBox(GetFocus(), (LPSTR)"Obtaining Global Memory.",
                (LPSTR)"GlobalAlloc()", MB_OK);
     hMemBlock = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT | GMEM_DISCARDABLE,
                             (long)sizeof(DWORD));

 /* if memory allocated properly */
     if (hMemBlock != NULL)
   {
   /* lock memory into current address */
   lpszMem = GlobalLock(hMemBlock);
   /* if lock worked */
   if (lpszMem != NULL)
       {
        MessageBox(GetFocus(), (LPSTR)"Locking Global Memory.",
                   (LPSTR)"GlobalLock()", MB_OK);
        FlagCall = GlobalFlags(hMemBlock);  /* get global flags */
        /* if discardable */
        if ((FlagCall & GMEM_DISCARDABLE))
           MessageBox(GetFocus(), (LPSTR)"This block is discardable.",
                      (LPSTR)"According to GlobalFlags()...", MB_OK);
        else
        MessageBox (GetFocus(), (LPSTR)"This block is NOT discardable.",
                    (LPSTR)"According to GlobalFlags()...", MB_OK);

        /* if lockcount 0 */
        if ((FlagCall & GMEM_LOCKCOUNT) == 0)
           MessageBox(GetFocus(),(LPSTR)"The lock count is 0.",
                      (LPSTR)"Before unlocking, according to GlobalFlags()..."
                      MB_OK);
        else
           MessageBox(GetFocus(),(LPSTR)"The lock count is NOT 0.",
                      (LPSTR)"Before unlocking, according to GlobalFlags()..."
                      MB_OK);

        MessageBox(GetFocus(), (LPSTR)"Unlocking Global Memory.",
                   (LPSTR)"GlobalUnlock()", MB_OK);
        unlocked = GlobalUnlock(hMemBlock);    /* unlock memory */
        FlagCall = GlobalFlags(hMemBlock);
        /* if lockcount 0 */
        if ((FlagCall & GMEM_LOCKCOUNT) == 0)
           {
           MessageBox(GetFocus(),(LPSTR)"The lock count is 0.",
                      (LPSTR)"After unlocking, According to GlobalFlags()...",
                      MB_OK);
           GlobalFree(hMemBlock);              /* free memory   */
           }
        else
           MessageBox(GetFocus(),(LPSTR)"The lock count is NOT 0.",
                      (LPSTR)"Before unlocking, according to GlobalFlags()..."
                      MB_OK);
        }
     else
        MessageBox(GetFocus(),(LPSTR)"The lock DID NOT work properly.",
                   (LPSTR)" ", MB_OK);
     }
     return 0;
 }


 GLOBFREE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBFREE.C

 /*
  *   This program demonstrates the use of the GlobalFree function. The
  *   GlobalFree function frees memory allocated from the Global heap.
  *   GlobalFree returns NULL if the memory is free. GlobalFree was called
  *   from WinMain in this sample application.
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {     /* structure we are going */
       int x;         /* to allocate and lock   */
       int y;
         } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;   /* Handle to memory block       */
     lpMyPtr  ThisPtr;   /* Pointer to myStruct          */
     char szBuff[30];     /* buffer for message box       */
     BOOL freed;         /* return value from GlobalFree */

     /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
                             (long)sizeof(MYSTRUCT));

     /* if memory allocated properly */
     if (hMemBlock != NULL)
        {
        /* lock memory into current address */
        ThisPtr = (lpMyPtr)GlobalLock(hMemBlock);

     /* if lock worked */
     if (ThisPtr != NULL)
        {
        /* use memory from global heap and output results*/
        ThisPtr->x = 4;
        ThisPtr->y = 4;
        ThisPtr->x = ThisPtr->x*ThisPtr->y;
        sprintf(szBuff,"ThisPtr->x * ThisPtr->y = %d",ThisPtr->x);
        MessageBox(GetFocus(),(LPSTR)szBuff,
                    (LPSTR)"Info from GlobalAlloc'ed memory",
                    MB_OK);
        GlobalUnlock(hMemBlock);        /* unlock memory */

        freed = GlobalFree(hMemBlock);    /* free memory */
        if (!freed)  /* if memory freed */
        MessageBox(GetFocus(),(LPSTR)"The memory was freed properly",
                  (LPSTR)" ",MB_OK);
        else      /* if memory not freed */
        MessageBox(GetFocus(),(LPSTR)"The memory WAS NOT freed",
                   (LPSTR)" ",MB_OK);
        }
    }
     return 0;
 }


 GLOBHAND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBHAND.C

 /*
  *   GlobalHandle
  *   globlock.c
  *
  *   This program demonstrates the use of the GlobalHandle function. The
  *   GlobalHandle function returns the handle of the specified global
  *   memory block. GlobalHandle is called from WinMain in this sample
  *   application.
  *
  */

 #include "windows.h"
  "dos.h"    /* FP_SEG located in dos.h */

 int sprintf();

 typedef struct {    /* structure we are going */
     int x;    /* to allocate and lock   */
     int y;
          } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock1;  /* Handle to memory block */
     DWORD hMemBlock2;   /* Handle to memory block returned from GlobalHandle
     lpMyPtr  FirstPtr;  /* Pointer to MYSTRUCT structure */
     char szBuff[30];  /* buffer for message box   */

 /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock1 = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(MYSTRUCT));

 /* if memory allocated properly */
     if (hMemBlock1 != NULL)
   {

   /* lock memory into current address */
   FirstPtr = (lpMyPtr)GlobalLock(hMemBlock1);

   /* if lock worked */
   if (FirstPtr != NULL)
       {
       /* get handle of segment pointed to by FirstPtr */
       hMemBlock2 = GlobalHandle(FP_SEG(FirstPtr));

       /* if GlobalHandle returned original handle */
       if ((HANDLE)hMemBlock2 == hMemBlock1)
          MessageBox(NULL,(LPSTR)"DID return the correct handle",
              (LPSTR)"GlobalHandle...",MB_OK);
       else
          MessageBox(NULL,(LPSTR)"DID NOT return the correct handle",
              (LPSTR)"GlobalHandle...",MB_OK);

       GlobalUnlock(hMemBlock1);   /* unlock memory */
       GlobalFree(hMemBlock1);   /* free memory   */
       }
   else
       MessageBox(NULL,(LPSTR)"The lock DID NOT work properly",
            (LPSTR)" ",MB_OK);
   }
     return 0;
 }


 GLOBLOCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBLOCK.C

 /*
 Function(s) demonstrated in this program: GlobalLock
 Compiler version: 5.10
 Description: When the right mouse button is clicked, this program will
        attempt to allocate and lock a small block of global memory.
        As a check, an arithmetic operation is performed on data
        stored in this global memory.
 */

 #include <windows.h>
 #include <stdio.h>

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 typedef struct {     /* structure we are going */
           int x;     /* to allocate and lock   */
           int y;
           } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;   /* far pointer to MYSTRUCT type */

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       nCmdShow;
 {
    static char szAppName [] = "globlock";
    HWND     hWnd;
    WNDCLASS wndclass;
    MSG      msg;

    if (!hPrevInstance)
       {
       wndclass.style          = CS_HREDRAW | CS_VREDRAW;
       wndclass.lpfnWndProc   = WndProc;
       wndclass.cbClsExtra    = 0;
       wndclass.cbWndExtra    = 0;
       wndclass.hInstance     = hInstance;
       wndclass.hIcon          = LoadIcon (NULL, IDI_APPLICATION);
       wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
       wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
       wndclass.lpszMenuName  = NULL;
       wndclass.lpszClassName = szAppName;

       if (!RegisterClass (&wndclass))
          return FALSE;
       }

    hWnd = CreateWindow (szAppName,   /* window class name   */
                         "Using GlobalLock (Click the Right Mouse Button for D
                         WS_OVERLAPPEDWINDOW,  /* window style            */
                         CW_USEDEFAULT,        /* initial x position      */
                         0,                    /* initial y position      */
                         CW_USEDEFAULT,        /* initial x size          */
                         0,                    /* initial y size          */
                         NULL,                 /* parent window handle    */
                         NULL,                 /* window menu handle      */
                         hInstance,            /* program instance handle */
                         NULL);                /* create parameters       */

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

    while (GetMessage(&msg, NULL, 0, 0))
       {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
       }
    return (msg.wParam);
 }

 long FAR PASCAL WndProc(hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
     HANDLE  hMemBlock;    /* Handle to memory block */
     lpMyPtr  ThisPtr;    /* far pointer to MYSTRUCT structure */
     char  szBuff[150];    /* buffer for message box */

     switch(iMessage)
        {
        case WM_RBUTTONDOWN:
           {
           hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
                                   (long)sizeof(MYSTRUCT));

           /* if memory allocated properly */
           if (hMemBlock)
              {
              /* lock memory into current address */
              ThisPtr = (lpMyPtr)GlobalLock(hMemBlock);

              /* if lock worked */
              if (ThisPtr)
                 {
                 MessageBox(GetFocus(),
                            (LPSTR)"The lock worked properly",
                            (LPSTR)"GlobalLock",
                            MB_OK);
                 /* use memory from global heap */
                 ThisPtr->x = 4;
                 ThisPtr->y = 4;
                 ThisPtr->x = ThisPtr->x * ThisPtr->y;
                 sprintf(szBuff, "%s%d", "The values referenced by these point
  in the global heap. \n\nThisPtr->x * ThisPtr->y = ", ThisPtr->x);
                 MessageBox(GetFocus(), (LPSTR)szBuff,
                            (LPSTR)"Info from GlobalLock'ed memory", MB_OK);
                 GlobalUnlock(hMemBlock);   /* unlock memory */
                 GlobalFree(hMemBlock);     /* free memory   */
                 }
              else
                 {
                 MessageBox(GetFocus(),
                            (LPSTR)"The lock DID NOT work properly",
                            (LPSTR)"GlobalLock", MB_OK);
                 GlobalFree(hMemBlock);     /* free memory   */
                 }
              }
           break;
           }
       case WM_DESTROY:
          {
          PostQuitMessage(0);
          break;
          }
       default:
          return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
    }
    return (0L);
 }


 GLOBREAL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBREAL.C

 /*
  *   GlobalReAlloc
  *   globreal.c
  *
  *   This program demonstrates the use of the GlobalReAlloc function. The
  *   GlobalRealloc changes the size of the specified allocated memory block
  *   and returns a handle to the different size memory block. GlobalSize
  *   was called from WinMain in this sample application.
  *
  */

 #include <windows.h>
 #include <stdio.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
     HANDLE hInstance, hPrevInstance;
     LPSTR lpszCmdLine;
     int cmdShow;
     {
     HANDLE hMemBlock;    /* Handle to memory block    */
     char szBuff[80];
     DWORD SizeMem;    /* holds sizes of memory blocks  */

     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, 200L);

     /* if memory allocated properly */
     if (hMemBlock)
   {
   MessageBox(NULL,"The memory was allocated properly",
        "GlobalAlloc",MB_OK);

   /* get the size of hMemBlock */
   SizeMem = GlobalSize(hMemBlock);
   sprintf(szBuff,"Size allocated = %lu",SizeMem);
   MessageBox(NULL, szBuff, "Before GlobalReAlloc...", MB_OK);

   hMemBlock = GlobalReAlloc(hMemBlock,    /* change the size of the */
           (DWORD)30,    /* allocated block to 30  */
           GMEM_MOVEABLE); /*     bytes      */
   if (hMemBlock)
       {
       SizeMem = GlobalSize(hMemBlock);
       sprintf(szBuff,"Size allocated = %lu",SizeMem);
       MessageBox(NULL, szBuff, "After GlobalReAlloc...",MB_OK);
       }
   else
       MessageBox(NULL, "GlobalReAlloc failed", "GlobaReAlloc",MB_OK);

   GlobalFree(hMemBlock);      /* free hMemblock */
   }
     return 0;
     }


 GLOBSIZE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBSIZE.C

 /*
  *   GlobalSize
  *
  *   This program demonstrates the use of the GlobalSize function. The
  *   GlobalSize function returns the size in bytes of the specified
  *   global memory block. GlobalSize was called from WinMain in this
  *   sample application.
  *
  */

 #include <windows.h>
 #include <stdio.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block      */
     char szBuff[ 40 ];    /* Local buffer for sprintf     */
     DWORD dwSizeMem;    /* holds sizes of memory blocks */

     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_NODISCARD, 400L );
          /* allocate space in global heap for a buffer */

     if ( hMemBlock != NULL )   /* if memory allocated properly */
     {
       dwSizeMem = GlobalSize( hMemBlock );
        /* Get the size of the block of memory  */
     sprintf( szBuff, "Size allocated = %lu", dwSizeMem);
     MessageBox( NULL, (LPSTR)szBuff, (LPSTR)"", MB_OK);
        /* Put size into string and output the string  */
       GlobalFree( hMemBlock );         /* free hMemblock */
     }

  return FALSE;
 }


 GLOBUNLK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBUNLK.C

 /*
  *   GlobalUnlock
  *
  *   This program demonstrates the use of the GlobalUnlock function. The
  *   GlobalUnlock function decrements the reference count of a block of
  *   memory allocated in the Global heap. GlobalUnlock returns zero if the
  *   reference count of the block is zero. GlobalUnlock was called from
  *   WinMain in this sample application.
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {    /* structure we are going */
     int x;    /* to allocate and lock   */
     int y;
          } MYSTRUCT;

 typedef MYSTRUCT far *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block */
     lpMyPtr  ThisPtr;    /* Pointer to myStruct    */
     char szBuff[30];    /* buffer for message box */
     BOOL unlocked;    /* return value from GlobalUnlock */

 /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(MYSTRUCT));

 /* if memory allocated properly */
     if (hMemBlock != NULL)
   {

   /* lock memory into current address */
   ThisPtr = (lpMyPtr)GlobalLock(hMemBlock);

   /* if lock worked */
   if (ThisPtr != NULL)
       {
       MessageBox(NULL,(LPSTR)"The lock worked properly",
            (LPSTR)" ",MB_OK);
       /* use memory from global heap and output results*/
       ThisPtr->x = 4;
       ThisPtr->y = 4;
       ThisPtr->x = ThisPtr->x*ThisPtr->y;
       sprintf(szBuff,"ThisPtr->x * ThisPtr->y = %d",ThisPtr->x);
       MessageBox(NULL,(LPSTR)szBuff,
           (LPSTR)"Info from GlobalLock'ed memory",
           MB_OK);

       /* unlock the block (decrement reference count) */
       unlocked = GlobalUnlock(hMemBlock);
       if (unlocked == 0)    /* if reference count == 0 */
     MessageBox (NULL,(LPSTR)"The block was properly unlocked",
          (LPSTR)" ",MB_OK);
       else    /* if (reference count != 0) */
     MessageBox (NULL,(LPSTR)"The block was NOT unlocked",
          (LPSTR)" ",MB_OK);

       GlobalFree(hMemBlock);  /* free memory   */
       }
   else
       MessageBox(NULL,(LPSTR)"The lock DID NOT work properly",
            (LPSTR)" ",MB_OK);
   }
     return 0;
 }


 GLOBUNWR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBUNWR.C

 /*
  *   GlobalUnWire
  *   globwire.c
  *
  *   This program demonstrates the use of the GlobalUnWire function. The
  *   GlobalUnWire function unlocks a block that has been locked into low
  *   memory using the GlobalWire function. GlobalUnWire is called from
  *   WinMain in this sample application.
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {
     char smallstruct[20];
          } SMALLSTRUCT;        /* structure we're going to allocate */
             /*   space for    */
 typedef SMALLSTRUCT far *lpSMALLPtr;  /* pointer to SMALLSTRUCT structure */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE    hMemBlock;   /* Handle to memory block       */
     lpSMALLPtr       ThisPtr;   /* Pointer to SMALLSTRUCT structure */
     char szBuff[50];     /* buffer for output         */

 /* Allocate space for SMALLSTRUCT in global heap */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(SMALLSTRUCT));
 /* if memory allocated properly */
     if (hMemBlock)
   /* GlobalWire the block into low memory */
   ThisPtr = (lpSMALLPtr)GlobalWire(hMemBlock);

 /******************** GlobalUnwire the block *******************************/
     GlobalUnWire(hMemBlock);

     MessageBox(NULL,(LPSTR)"The block has been GlobalUnwire'ed",
         (LPSTR)" ",MB_OK);

 /* Free the block */
     GlobalFree(hMemBlock);  /* free the block */

     return 0;
 }


 GLOBWIRE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\GLOBAL\GLOBWIRE.C

 /*
  *   GlobalWire
  *   globwire.c
  *
  *   This program demonstrates the use of the GlobalWire function. The
  *   GlobalWire function locks a block into low memory. GlobalWire is
  *   called from WinMain in this sample application. GlobalWire is often
  *   used when a block is going to be locked in memory for a long time
  *   so there will be larger continuous free spaces than if GlobalLock was
  *   used. Before allocation  and after GlobalWire'ing, GlobalCompact is
  *   called to show the affect of locking the block in memory has on the
  *   largest continuous block
  *
  */

 #include "windows.h"

 int sprintf();

 typedef struct {
     char smallstruct[20];
          } SMALLSTRUCT;        /* structure we're going to allocate */
             /*   space for    */
 typedef SMALLSTRUCT far *lpSMALLPtr;  /* pointer to SMALLSTRUCT structure */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE     hMemBlock;       /* Handle to memory block    */
     lpSMALLPtr     ThisPtr;       /* Pointer to myStruct    */
     char     szBuff[80];       /* buffer for output    */
     DWORD     ContigFreeBytes;  /* return value from GlobalCompact */

 /* Allocate space for SMALLSTRUCT in global heap */
     hMemBlock = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(SMALLSTRUCT));
 /* if memory allocated properly */
     if (hMemBlock)
   /* GlobalWire the block into low memory */
   ThisPtr = (lpSMALLPtr)GlobalWire(hMemBlock);
   if (ThisPtr == NULL)
       MessageBox(NULL,(LPSTR)"GlobalWire Failure",
           (LPSTR)" ",MB_OK);
   else
       MessageBox(NULL,(LPSTR)"GlobalWire worked properly",
           (LPSTR)" ",MB_OK);

 /* GlobalUnwire the block */
     GlobalUnWire(hMemBlock);

 /* Free the block */
     GlobalFree(hMemBlock);

     return 0;
 }


 GMENUITC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GMENUITC.C

 /*
  *
  *  GetMenuItemCount
  *
  *  This program demonstrates the use of the function GetMenuItemCount.
  *  This function determines the number of items in the menu identifed by
  *  the parameter.  This may be either a pop-up of top-level menu.
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFileName[] = "gmenuitc";
   static char szFuncName[] = "GetMenuItemCount";
   HMENU hMenu;
   WORD wCount;
   char szBuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) szFileName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) "GetMenuItemCountFunc";
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) szFileName, ( LPSTR ) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hMenu = GetMenu ( hWnd );

   MessageBox (NULL, (LPSTR)"Getting number of menu items", (LPSTR) szFuncName
      MB_OK);

   wCount = GetMenuItemCount ( hMenu );

   if ( wCount != -1 )
      {
      sprintf ( szBuff, "%s%d", "Number of menu items is ", wCount );
      MessageBox (NULL, (LPSTR) szBuff, (LPSTR) szFuncName, MB_OK);
      }
   else
      MessageBox (NULL, (LPSTR)"Error", (LPSTR) szFuncName,
         MB_OK|MB_ICONEXCLAMATION);

   return 0;
 }


 GMENUITI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GMENUITI.C

 /*
  *  GetMenuItemID
  *
  *  This program demonstrates the use of the function GetMenuItemID.
  *  This function
  *
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFileName[] = "gmenuiti";
   static char szFuncName[] = "GetMenuItemID";
   HMENU hMenu;
   WORD wID;
   char szBuff[80];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) szFileName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) "GetMenuItemCountFunc";
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) szFileName, ( LPSTR ) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hMenu = GetMenu ( hWnd );

   MessageBox (NULL, (LPSTR)"Getting ID of menu item Before", (LPSTR) szFuncNa
      MB_OK);

   wID = GetMenuItemID ( hMenu, 0 );

   if ( wID != -1 )
      {
      sprintf ( szBuff, "%s%d", "ID of menu item Before is ", wID );
      MessageBox (NULL, (LPSTR) szBuff, (LPSTR) szFuncName, MB_OK);
      }
   else
      MessageBox (NULL, (LPSTR)"Error", (LPSTR) szFuncName,
         MB_OK|MB_ICONEXCLAMATION);

   return 0;
 }


 GMENUSTR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GMENUSTR.C

 /*
  *
  * GetMenuString
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetMenuString function
  *  if the user selects the "GetMenuString" selection from the main menu bar.
  *  If the function call is successful, a message box is created which
  *  copies the menu string into a buffer.  The function is duplicated for
  *  use by position of the menu selection and by the resource ID.
  *
  */

 #include "windows.h"
   IDM_TEST      100     /* ID of the Test menu.    */
   N_MAX_COUNT   14      /* Temporary buffer count. */
   SIZE_OUTBUFF  36      /* Output Buffer size.     */

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;     /* Handle to the Display Context. */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gmenustr";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)"TestMenu";            /* Load the menu. *
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gmenustr",
            (LPSTR) "GetMenuString",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0,0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    } /* while */


 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    char szbuf[N_MAX_COUNT];     /* Temp Buffer, stores results of function */
    char szoutbuf[SIZE_OUTBUFF]; /* Formatted output buffer for message Box */
    short int nCopied;           /* Number of characters copied, error chk  */

    switch (identifier) {                              /*******************/
     case WM_COMMAND:                                  /* Process the     */
        switch (wParam) {                              /* menu selections */
        case IDM_TEST:                                /* here.           */
            nCopied = GetMenuString(GetMenu(hWnd),     /* Get the string  */
                                    wParam,            /* of the menu and */
                                    (LPSTR) szbuf,     /* put it into a   */
                                    N_MAX_COUNT,       /* temporary buf-  */
                                    MF_BYCOMMAND);     /* fer by command. */
            if (nCopied == 0)                            /* If no charac- */
              {                                          /* ters were     */
              MessageBox(hWnd,                           /* copied, issue */
                         (LPSTR)"GetMenuString Failed!", /* an error in   */
                         (LPSTR)"ERROR!!!",              /* the form of a */
                         MB_OK | MB_ICONEXCLAMATION);    /* message box.  */
              break;
              }
            else                                       /* Otherwise, put  */
              {                                        /* a more meaning- */
              sprintf(szoutbuf,                        /* ful message in  */
                      "%s%s%s",                        /* a buffer for    */
                      "The Menu String is '",          /* the user to     */
                      szbuf,                           /* recognize.      */
                      "'");                            /* Then...         */
              MessageBox(hWnd,                         /* show the result */
                         (LPSTR)szoutbuf,              /* in a message    */
                         (LPSTR)"MF_BYCOMMAND",        /* box.            */
                         MB_OK);
              nCopied = GetMenuString(GetMenu(hWnd),   /* Now, get the    */
                                      0,               /* same string     */
                                      (LPSTR)szbuf,    /* from the same   */
                                      N_MAX_COUNT,     /* menu by using   */
                                      MF_BYPOSITION);  /* the position of */
              if (nCopied == 0)                        /* the menu.       */
                 {                                     /* If no charac-   */
                 MessageBox(hWnd,                      /* ters were       */
                            (LPSTR)"GetMenuString Failed!", /* found,     */
                            (LPSTR)"MF_BYPOSITION",         /* issue an   */
                            MB_OK | MB_ICONEXCLAMATION);    /* error in a */
                 break;                                /* message box.    */
                 }
              else                                     /* Finally,        */
                 {                                     /* display the     */
                 sprintf(szoutbuf,                     /* results of the  */
                         "%s%s%s",                     /* GetMenuString   */
                         "The Menu String is '",       /* using position  */
                         szbuf,                        /* rather than ID. */
                         "'");                         /* But put it in a */
                 MessageBox(hWnd,                      /* form which is   */
                            (LPSTR)szoutbuf,           /* more pleasing   */
                            (LPSTR)"MF_BYPOSITION",    /* to the user.    */
                            MB_OK);                    /*******************/
                 };
             break;
              }
        }

     default:
        return(DefWindowProc(hWnd, identifier, wParam, lParam));
        break;

    }

    return(0L);

 }


 GMESSPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GMESSPOS.C

 /*
  *
  * GetMessagePos
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user proceeds to close the window, the GetMessagePos
  *  function is executed.  The mouse coordinates are then displayed on
  *  the screen in a message box before the window is actually closed and
  *  destroyed.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gmesspos";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, (LPSTR)"simpleton");
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style        = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gmesspos",
            (LPSTR) "GetMessagePos",
            WS_OVERLAPPEDWINDOW,         /* Use overlapped window.   */
            CW_USEDEFAULT,               /* Use default coordinates. */
            CW_USEDEFAULT,               /* Use default coordinates. */
            CW_USEDEFAULT,               /* Use default coordinates. */
            CW_USEDEFAULT,               /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);       /* Paint a window  */
        SetMapMode(hDC, MM_ANISOTROPIC);                /* which will tell */
        SetWindowOrg(hDC, 0, 0);                        /* the user to     */
        SetWindowExt(hDC, 110, 110);                    /* double click    */
        GetClientRect(hWnd, (LPRECT)&rRect);            /* the right mouse */
        SetViewportOrg(hDC, 0, 0);                      /* button to con-  */
        SetViewportExt(hDC, rRect.right, rRect.bottom); /* the test.       */
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button to Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);

     }
       break;

     case WM_RBUTTONDBLCLK: {                  /* If the user double       */
                                               /*  clicks the right        */
        char szbuf[32];                        /*  mouse button, then      */
        unsigned long ptPos;                   /*  an output buffer is     */
        POINT point;                           /*  allocated along with    */
                                               /*  a pointer to a position */
        ptPos = GetMessagePos();               /*  and a point.  The fn    */
       point = MAKEPOINT(ptPos);              /*  GetMessagePos is exec-  */
       sprintf(szbuf,                         /*  uted and the mouse      */
                "%s%d%s%d%s",                  /*  position is printed in  */
                "The Mouse Position is ",      /*  a messge box.           */
               point.x, ",", point.y, ".");
       MessageBox(hWnd,
                   (LPSTR)szbuf,
                   (LPSTR)"GetMessagePos",
                  MB_OK);
        }
        break;

     case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GMESSTIM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\GMESSTIM.C

 /*
  *
  * GetMessageTime
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user proceeds to close the window, the GetMessagePos
  *  function is executed.  The time (in milliseconds) since the last
  *  are then displayed on the screen in a message box before the window
  *  is actually closed and destroyed.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gmesstim";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gmesstim",
            (LPSTR) "GetMessageTime",       /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[40];   /* Output buffer       | mouse button, then   */
        long lTime;   /* Time since last message | establish needed     */
                                                /* variables and call   */
        lTime = GetMessageTime();               /* the GetMessageTime   */
       sprintf(szbuf,                          /* function.  Capture   */
                "%s%ld%s\0",                    /* the time information */
                "Time Since Last Message is ",  /* in a zero terminated */
               lTime,                          /* buffer.              */
                ".");
       MessageBox(hWnd,                        /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetMessageTime",     /* so that the user can */
                  MB_OK);                      /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GMETAFB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\GMETAFB.C

 /*
  *  This program demonstrates the use of the function GetMetaFileBits.
  *  This function returns a handle to a global memory block containing the
  *  specified metafile as a collection of bits.
  */

 #include <windows.h>

 static HANDLE hWnd;
 HANDLE hMem;

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFuncName[] = "GetMetaFileBits()";
   char szOutBuf[40];
   HANDLE hMF;
   HANDLE hMetaDC;

   MessageBox(GetFocus(), (LPSTR)"Creating Memory Metafile",
              (LPSTR)"CretaeMetaFile()", MB_OK);
   hMetaDC = CreateMetaFile(NULL);
   if (hMetaDC == NULL)
      MessageBox(GetFocus(), (LPSTR)"Error in Creating Memory Metafile",
                 (LPSTR)"CreateMetaFile() Error!", MB_OK | MB_ICONEXCLAMATION)
   else {
      Rectangle(hMetaDC, 10, 10, 200, 200);
      Rectangle(hMetaDC, 201, 10, 401, 200);
      LineTo(hMetaDC, 100, 250);
      Ellipse(hMetaDC, 0, 0, 100, 100);
      hMF = CloseMetaFile(hMetaDC);
      MessageBox (GetFocus(),
                  (LPSTR)"Getting Handle to Metafile Bits",
                  (LPSTR)szFuncName, MB_OK);
      hMem = GetMetaFileBits(hMF);
      if (hMem == NULL)
         MessageBox (GetFocus(), (LPSTR)"Error in Obtaining Metafile Bit Handl
                     (LPSTR)szFuncName, MB_OK);
      else {
         MessageBox (GetFocus(), (LPSTR)"Handle Obtained Successfully",
                     (LPSTR)szFuncName, MB_OK);
         if (GlobalSize(hMem) != 0) {
            sprintf(szOutBuf, "%s%lu%s", "The Size of the Metafile is: ",
                    GlobalSize(hMem), " bytes.");
            MessageBox(GetFocus(), (LPSTR)szOutBuf, (LPSTR)"GlobalSize()", MB_
            }
         else
            MessageBox(GetFocus(), (LPSTR)"Error in Obtaining the Size of the
                       (LPSTR)"GlobalSize", MB_OK);
         }
      }
   return 0;
 }


 GMETAFIL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\GMETAFIL.C

 /*
  *
  *  GetMetaFile
  *
  *  This program demonstrates the use of the function GetMetaFile.
  *  This function creates a handle for the metafile named by the parameter.
  *
  */

 #include <windows.h>

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   static char szFileName[] = "gmetafil";
   static char szFuncName[] = "GetMetaFile";
   HDC hDC;
   HANDLE hMF;

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) szFileName;
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) "GetMenuFunc";
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) szFileName, ( LPSTR ) szFuncName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HWND ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   hDC = GetDC ( hWnd );

   MessageBox (NULL, (LPSTR)"Getting handle to metafile", (LPSTR) szFuncName,
      MB_OK);

   hMF = GetMetaFile ( (LPSTR) "GMETAFIL.MET" );

   if ( hMF != NULL )
      MessageBox (NULL, (LPSTR)"Metafile handle gotten", (LPSTR) szFuncName,
         MB_OK);
   else
      MessageBox (NULL, (LPSTR)"Metafile handle not gotten", (LPSTR) szFuncNam
         MB_OK);

   PlayMetaFile ( hDC, hMF );
   MessageBox (NULL, (LPSTR)"This is the metafile", (LPSTR) szFuncName, MB_OK)
   ReleaseDC ( hWnd, hDC);
   return 0;
 }


 GMNUSTAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GMNUSTAT.C

 /*
  *
  * GetMenuState
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  When the user executes the "Test" menu selection, the
  *  state of the popup menu selection "Item 2", in the "GetMenuState"
  *  menu, is verified as "CHECKED" in a message box.  Otherwise, an
  *  error message is issued, also in the form of a message box.
  *
  */

 #include "windows.h"
   IDM_TEST       100  /* ID of the Test menu.                */
   IDM_ITEM2      102  /* ID of Item 2.                       */
   IDM_GETMENUPOS   1  /* Position of the GetMenuState Popup. */
   SIZE_OUTBUFF    80  /* Output Buffer size.                 */

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;     /* Handle to the Display Context. */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gmnustat";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)"TestMenu";            /* Load the menu. *
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gmnustat",
            (LPSTR) "GetMenuState",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0,0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    } /* while */


 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    char szoutbuf[SIZE_OUTBUFF]; /* Formatted output buffer for message Box */
    WORD wMState;                /* The WORD state of the menu selection.   */

    switch (identifier) {                              /*******************/
     case WM_COMMAND:                                  /* Process the     */
        switch (wParam) {                              /* menu selections */
        case IDM_TEST:                                /* here.           */
            wMState = GetMenuState(GetSubMenu(GetMenu(hWnd),
                                              IDM_GETMENUPOS),
                                   IDM_ITEM2,          /* Get the number  */
                                   MF_BYCOMMAND);      /* of the menu     */
                                                       /* a temp buffer.  */
            if (wMState == NULL)                       /* If the menu    */
              {                                          /* does not      */
              MessageBox(hWnd,                           /* exist, issue  */
                         (LPSTR)"Menu Does Not Exist!",  /* an error in   */
                         (LPSTR)"ERROR!!!",              /* the form of a */
                         MB_OK | MB_ICONEXCLAMATION);    /* message box.  */
              break;
              }
            else                                       /* Otherwise, put  */
              {                                        /* a more meaning- */
              if (wMState && MF_CHECKED != 0)
                 {
                 sprintf(szoutbuf,                        /* ful message in  *
                         "%s%s",                       /* a buffer for    */
                         "The State of GetMenuState ", /* the user to     */
                         "(Item 2) is CHECKED.");      /* recognize.      */
                 MessageBox(hWnd,                      /* Then...         */
                            (LPSTR)szoutbuf,           /* show the result */
                            (LPSTR)"GetMenuState",     /* in a message    */
                            MB_OK);                    /* box.            */
                 }
              else
                 {
                 sprintf(szoutbuf,
                         "%s%s",
                         "The State of GetMenuState ",
                         "(Item 2) is UNCHECKED.");
                 MessageBox(hWnd,
                            (LPSTR)szoutbuf,
                            (LPSTR)"GetMenuState",
                            MB_OK);
                 }
             break;
              }
        }

     default:
        return(DefWindowProc(hWnd, identifier, wParam, lParam));
        break;

    }

    return(0L);

 }


 GNEARCLR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GNEARCLR.C

 /*
  * This example demonstrates the use of GetNearestColor(). This example
  * begins with the main menu selection where the user enters RGB values
  * into a dialog box. These values are used to compute the nearest
  * color and displayed in a message box. This loop continues until the
  * user chooses the "Done" selection.
  *
  */

 #include "windows.h"
 #include <stdio.h>
 #include "gnearclr.h"

 /* Global Variables */
 static HANDLE hInst;
 FARPROC lpprocColor;

 /* Forward References */
 long FAR PASCAL NearestWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL ColorDlg(HWND, unsigned, WORD, LONG);

 /* Color Dialog Function */
 BOOL FAR PASCAL ColorDlg(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
    char szOutBuf[80];      /* Output Buffer for Message Box    */
    unsigned uiRValue;      /* Edit Input for Red Value         */
    unsigned uiGValue;      /* Edit Input for Green Value       */
    unsigned uiBValue;      /* Edit Input for Blue Value        */
    BOOL bSuccess;          /* Flag if All Edit Values are Good */
    DWORD dwrgbValue;       /* RGB Value of Nearest Color       */
    HDC hDC;                /* Display Context of Dialog Box    */
    BOOL bReceived;         /* Flag if Edit Received Set Value  */

    switch (message) {
       case WM_COMMAND:
          switch (wParam) {
             case ID_DONE:  /* If all done, quit the dialog box */
                EndDialog(hDlg, TRUE);
                return TRUE;

             case ID_MYOK:  /* If ready to accept dialog values */
                /* Innocent until proven guilty */
                bSuccess = TRUE;
                /* Get all of the edit values and check them for range */
                uiRValue = GetDlgItemInt(hDlg, ID_REDIT,
                                         (BOOL FAR *)&bReceived, NULL);
                if ((bReceived == NULL) || (uiRValue > 255) ||
                    (uiRValue < 0))
                   {
                   MessageBox(hDlg, (LPSTR)"Invalid Red Value",
                              (LPSTR)"Range Error (0-255)!", MB_OK);
                   bSuccess = FALSE;
                   }
                uiGValue = GetDlgItemInt(hDlg, ID_GEDIT,
                                         (BOOL FAR *)&bReceived, NULL);
                if ((bReceived == NULL) || (uiGValue > 255) ||
                    (uiGValue < 0))
                   {
                   MessageBox(hDlg, (LPSTR)"Invalid Green Value",
                              (LPSTR)"Range Error (0-255)!", MB_OK);
                   bSuccess = FALSE;
                   }
                uiBValue = GetDlgItemInt(hDlg, ID_BEDIT,
                                         (BOOL FAR *)&bReceived, NULL);
                if ((bReceived == NULL) || (uiBValue > 255) ||
                    (uiBValue < 0))
                   {
                   MessageBox(hDlg, (LPSTR)"Invalid Blue Value",
                              (LPSTR)"Range Error (0-255)!", MB_OK);
                   bSuccess = FALSE;
                   }
                if (bSuccess) { /* If all are OK, continue */
                   /* Get the DC and get the nearest color of the user's
                      input. */
                   hDC = GetDC(hDlg);
                   dwrgbValue = GetNearestColor(hDC, RGB((BYTE)uiRValue,
                                                         (BYTE)uiGValue,
                                                         (BYTE)uiBValue)
                                               );
                   ReleaseDC(hDlg, hDC);
                   sprintf(szOutBuf, "%s%d%s%d%s%d%s",
                           "The Nearest Color is: (",
                           GetRValue(dwrgbValue),
                           " , ", GetGValue(dwrgbValue),
                           " , ", GetBValue(dwrgbValue), ").");
                   /* Print a message box and set the focus back so that
                      the user can enter values at will in a loop. */
                   MessageBox(hDlg, (LPSTR)szOutBuf,
                              (LPSTR)"GetNearestColor()", MB_OK);
                   }
                SetFocus(GetDlgItem(hDlg, ID_REDIT));
                SendMessage(GetDlgItem(hDlg, ID_REDIT), EM_SETSEL, NULL,
                            MAKELONG((WORD)0, (WORD)32767));
                return TRUE;

             default:
                return FALSE;
             };
          break;

       case WM_INITDIALOG:
          /* When the box first comes up, limit the text for each
             numeric value to three digits so that the user is
             less likely to enter an erroneus value. */
          SendMessage(GetDlgItem(hDlg, ID_REDIT), EM_LIMITTEXT,
                      (WORD)3, (LONG)NULL);
          SendMessage(GetDlgItem(hDlg, ID_GEDIT), EM_LIMITTEXT,
                      (WORD)3, (LONG)NULL);
          SendMessage(GetDlgItem(hDlg, ID_BEDIT), EM_LIMITTEXT,
                      (WORD)3, (LONG)NULL);
          /* Intialize all of the edit controls to zero. */
          SetDlgItemInt(hDlg, ID_REDIT, (unsigned)0, NULL);
          SetDlgItemInt(hDlg, ID_GEDIT, (unsigned)0, NULL);
          SetDlgItemInt(hDlg, ID_BEDIT, (unsigned)0, NULL);
          SetFocus(GetDlgItem(hDlg, ID_REDIT));
          SendMessage(GetDlgItem(hDlg, ID_REDIT), EM_SETSEL, NULL,
                      MAKELONG((WORD)0, (WORD)32767));
          return FALSE;

       default:
          return FALSE;
       }
 }


 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG       msg;
     HWND      hWnd;
     PWNDCLASS pNearClass;

     if (!hPrevInstance) {
        pNearClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

        pNearClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
        pNearClass->hIcon          = NULL;
        pNearClass->lpszMenuName   = (LPSTR)"NearMenu";
        pNearClass->lpszClassName  = (LPSTR)"gnearclr";
        pNearClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
        pNearClass->hInstance      = hInstance;
        pNearClass->style          = CS_HREDRAW | CS_VREDRAW;
        pNearClass->lpfnWndProc    = NearestWndProc;

        if (!RegisterClass((LPWNDCLASS)pNearClass))
            /* Initialization failed.
             * Windows will automatically deallocate all allocated memory.
             */
            return FALSE;

        LocalFree((HANDLE)pNearClass);
         }

     hWnd = CreateWindow((LPSTR)"gnearclr",
                         (LPSTR)"GetNearestColor() Demo",
                         WS_TILEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL);      /* no params to pass on */

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Bind callback function with module instance */
     lpprocColor = MakeProcInstance((FARPROC)ColorDlg, hInstance);

     /* Make window visible according to the way the app is activated */
     ShowWindow(hWnd, cmdShow);
     UpdateWindow(hWnd);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL NearestWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_COMMAND:
         switch (wParam)
         {
         case ID_NEAR:
            /* Let 'er rip. */
             DialogBox(hInst, MAKEINTRESOURCE(NEARBOX), hWnd, lpprocColor);
             break;
         default:
             return DefWindowProc(hWnd, message, wParam, lParam);
         }
         break;

     case WM_DESTROY:
         PostQuitMessage(0);
         break;

     default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
     }
     return(0L);
 }


 GNEXTITM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\GNEXTITM.C

 /*
  * This application demonstrates the use of GetNextDlgGroupItem() and
  * GetNextDlgTabItem(). In the dialog box, choosing the radiobutton
  * and selecting the direction and the "NextTab" or "NextGroup" push
  * button will change the focus to the next repsective item -- depending
  * upon whether the previous flag and the "Tab" or "Group" selection.
  *
  */

 #include "windows.h"
 #include "gnextitm.h"

 /* Global Variables */
 static HANDLE hInst;       /* Instance handle for dialog box.          */
 FARPROC       lpprocNext;  /* Long pointer to dialog procedure.        */
 HWND          hGrpCurrent; /* Handle to the current group push button. */
 HWND          hTabCurrent; /* Handle to the current tab push button.   */
 BOOL          bDirCurrent; /* Current direction to get the next item.  */

 /* Forward References */
 long FAR PASCAL NextWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL NextItem(HWND, unsigned, WORD, LONG);

 /* Dialog Procedure */
 BOOL FAR PASCAL NextItem(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
    HWND hGNextItem; /* Next Group Item */
    HWND hTNextItem; /* Next Tab Item   */
    int  i;          /* Counter         */

    switch (message) {
       case WM_COMMAND:
          switch (wParam) {
             case ID_DONE: /* If all done, quit */
                EndDialog(hDlg, TRUE);
                return TRUE;

             case ID_DIRECTION: /* Change the "Previous" flag for direction */
                if (bDirCurrent == TRUE)
                   bDirCurrent = FALSE;
                else
                   bDirCurrent = TRUE;
                return TRUE;

             case ID_TABFRST: /* Manually set the tab button focus */
             case ID_TABSEC:
             case ID_TABTHRD:
                CheckRadioButton(hDlg, ID_TABFRST,
                                 ID_TABTHRD, wParam);
                hTabCurrent = GetDlgItem(hDlg, wParam);
                return TRUE;

             case ID_GRPFRST: /* Manually set the group button focus */
             case ID_GRPSEC:
             case ID_GRPTHRD:
                CheckRadioButton(hDlg, ID_GRPFRST,
                                 ID_GRPTHRD, wParam);
                hGrpCurrent = GetDlgItem(hDlg, wParam);
                return TRUE;

             case ID_NEXTTAB: /* Get the next tab item */
                /* The first two cases are needed because the dialog
                   manager does neat things with tabs. */
                if ((hTabCurrent == GetDlgItem(hDlg, ID_TABFRST)) &&
                    (bDirCurrent == TRUE)) {
                    CheckRadioButton(hDlg, ID_TABFRST,
                                     ID_TABTHRD, ID_TABTHRD);
                    hTabCurrent = GetDlgItem(hDlg, ID_TABTHRD);
                    }
                else if ((hTabCurrent == GetDlgItem(hDlg, ID_TABTHRD)) &&
                         (bDirCurrent == FALSE)) {
                    CheckRadioButton(hDlg, ID_TABFRST,
                                     ID_TABTHRD, ID_TABFRST);
                    hTabCurrent = GetDlgItem(hDlg, ID_TABFRST);
                    }
                else { /* Finally, you can do things properly */
                   hTNextItem = GetNextDlgGroupItem(hDlg,
                                                   hTabCurrent,
                                                   bDirCurrent);
                   hTabCurrent = hTNextItem;
                   for (i = ID_TABFRST; i <= ID_TABTHRD; i = i + 25)
                      if (GetDlgItem(hDlg, i) == hTabCurrent)
                         CheckRadioButton(hDlg, ID_TABFRST,
                                          ID_TABTHRD, i);
                   }
                return TRUE;

             case ID_NEXTGROUP: /* Groups are much neater to implement */
                hGNextItem = GetNextDlgGroupItem(hDlg,
                                                hGrpCurrent,
                                                bDirCurrent);
                hGrpCurrent = hGNextItem;
                for (i = ID_GRPFRST; i <= ID_GRPTHRD; i = i + 25)
                   if (GetDlgItem(hDlg, i) == hGrpCurrent)
                      CheckRadioButton(hDlg, ID_GRPFRST,
                                       ID_GRPTHRD, i);
                return TRUE;

             default:
                return FALSE;
             }

       case WM_INITDIALOG: /* Initalize everything */
          hTabCurrent = GetDlgItem(hDlg, ID_TABFRST);
          CheckRadioButton(hDlg, ID_TABFRST, ID_TABTHRD, ID_TABFRST);
          hGrpCurrent = GetDlgItem(hDlg, ID_GRPFRST);
          CheckRadioButton(hDlg, ID_GRPFRST, ID_GRPTHRD, ID_GRPFRST);
          bDirCurrent = FALSE;
          CheckDlgButton(hDlg, ID_DIRECTION, bDirCurrent);
          SetFocus(GetDlgItem(hDlg, ID_DONE));
          return FALSE;

       default:
          return FALSE;
       }
 }

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance) {
        PWNDCLASS   pNextClass;

        pNextClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

        pNextClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
        pNextClass->hIcon          = (HANDLE)NULL;
        pNextClass->lpszMenuName   = (LPSTR)"NextMenu";
        pNextClass->lpszClassName  = (LPSTR)"gnextitm";
        pNextClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
        pNextClass->hInstance      = hInstance;
        pNextClass->style          = CS_HREDRAW | CS_VREDRAW;
        pNextClass->lpfnWndProc    = NextWndProc;

        if (!RegisterClass((LPWNDCLASS)pNextClass))
            /* Initialization failed.
             * Windows will automatically deallocate all allocated memory.
             */
            return FALSE;

        LocalFree((HANDLE)pNextClass);
        }

     hWnd = CreateWindow((LPSTR)"gnextitm",
                         (LPSTR)"GetNextDlgTabItem() & GetNextDlgGroupItem() D
                         WS_TILEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent                 */
                         (HMENU)NULL,       /* use class menu            */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL);      /* no params to pass on      */

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Bind callback function with module instance */
     lpprocNext = MakeProcInstance((FARPROC)NextItem, hInstance);

     /* Make window visible according to the way the app is activated */
     ShowWindow(hWnd, cmdShow);
     UpdateWindow(hWnd);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL NextWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message)
     {
     case WM_COMMAND:
         switch (wParam)
         {
         case ID_NEXTBOX: /* Go for it! */
             DialogBox(hInst, MAKEINTRESOURCE(NEXTBOX), hWnd, lpprocNext);
             break;

         default:
             return DefWindowProc(hWnd, message, wParam, lParam);
         }
         break;

     case WM_DESTROY:
         PostQuitMessage(0);
         break;

     default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
     }
     return(0L);
 }


 GNEXTWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\GNEXTWIN.C

 /*
  *
  *   gnextwin.c
  *
  *   This program demonstrates the use of the GetNextWindow() function.
  *   GetNextWindow() searches for a handle that identifies the next (or
  *   previous window, depending on the second parameter) in the window-
  *   manager's list. GetNextWindow() is called from WinMain() in this
  *   application, and if a non-null handle is returned, CloseWindow() is
  *   is called to make the window whose handle was returned iconic. If
  *   this application's window is not the active window, but no other
  *   window is over it, then that may mean the previous window is the
  *   blank window that you see in the background.
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon          = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"GetNextWindow";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     HWND  hNextWindow;   /*** return value from GetNextWindow() ***/

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"GetNextWindow",
                         (LPSTR)"GetNextWindow()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(NULL,
                (LPSTR)"     If a non-null handle is returned, the window\n\
 corresponding to this handle is brought to the\n\
 top.",
                (LPSTR)"This application calls GetNextWindow().",
                MB_OK);

 /***   get the handle to the next window in window-manager's list  ***/

     hNextWindow = GetNextWindow(hWnd,GW_HWNDNEXT);

     if (!hNextWindow)
         MessageBox(NULL,
                    (LPSTR)"There is no next window",
                    (LPSTR)"GetNextWindow() info:",
                    MB_OK);
     else if (hNextWindow == hWnd)
         MessageBox(NULL,
                    (LPSTR)"which is already the top window",
                    (LPSTR)"GetNextWindow returned this window...",
                    MB_OK);
     else if ( !IsIconic(hNextWindow) )
         BringWindowToTop(hNextWindow);
     else
         ShowWindow(hNextWindow,SW_SHOWMAXIMIZED);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GRAY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\GRAY.C

 /*
  *   GrayString
  *
  *   This program demonstrates the use of the GrayString function. The
  *   GrayString function outputs gray text to the specified window.
  *
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     HDC   hDC;          /* Handle to display context */
     HBRUSH hMyBrush;        /* Handle to a brush   */
     DWORD gray=RGB(0x22,0x22,0x22); /* Red, Green, Blue, values for brush */

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

 /******************************************************************/
   /* get handle to display context */
      hDC = GetDC(hWnd);
   /* create brush with the colors specified by "gray" */
     hMyBrush = CreateSolidBrush(gray);
   /* if brush not created succesfully */
     if (hMyBrush = NULL)
   /* output error */
   MessageBox(hWnd,(LPSTR)"Unable to Create Brush",(LPSTR)"Too Bad",
        MB_OK);
     else
   /* else output gray text */

   GrayString(hDC,hMyBrush,NULL,(DWORD)(LPSTR)"This is gray text",0,5,5,0,0);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GSPOLYFM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GSPOLYFM.C

 /*
 Function(s) demonstrated in this program: GetPolyFillMode
             SetPolyFillMode

 Description:  This program demonstrates differences in the two
         Polygon filling modes, ALTERNATE and WINDING.  In ALTERNATE
         mode, every other region is filled.  In WINDING, all regions
         are filled.  The two shapes drawn here demonstrate the
         difference.

         SetPolyFillMode is used to select the mode;

         GetPolyFillMode is used to retrieve the current fill mode and
         print it on the screen while the polygon is drawn.

 */

 #include <windows.h>

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 void DrawPoly (HDC, short, short, short, short);


 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     static char szAppName[]="Get/Set/PolyFillMode";
     static BYTE byExtra[]={32,66,121,32,75,114,97,105,103,32,
          66,114,111,99,107,115,99,104,109,105,100,116,32};
     HWND  hWnd;
     WNDCLASS  wndclass;
     MSG   msg;

     if (!hPrevInstance)
    {
    wndclass.style   = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc  = WndProc;
    wndclass.cbClsExtra  = 0;
    wndclass.cbWndExtra  = 0;
    wndclass.hInstance  = hInstance;
    wndclass.hIcon   = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor  = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName  = szAppName;
    wndclass.lpszClassName = szAppName;

    if (!RegisterClass(&wndclass))
         return FALSE;
    }

     hWnd=CreateWindow(szAppName, szAppName,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
        NULL, NULL, hInstance, NULL);

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

     while (GetMessage(&msg, NULL, 0, 0))
   {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
   }
     return (msg.wParam);
     }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
     HWND  hWnd;
     unsigned  iMessage;
     WORD  wParam;
     LONG  lParam;
     {
     HDC   hDC;
     HMENU  hMenu;
     HPEN  hPen;
     PAINTSTRUCT ps;

     switch(iMessage)
   {
   case WM_PAINT:
       hDC=BeginPaint(hWnd, &ps);
       hPen=CreatePen(PS_SOLID, 2, 0L);

       SelectObject(hDC, hPen);
       SelectObject(hDC, GetStockObject(GRAY_BRUSH));

       TextOut(hDC, 10, 10, "PolyFillMode=", 13);
       TextOut(hDC, 10, 190, "ALTERNATE", 9);
       TextOut(hDC, 140,190, "WINDING", 7);

       DrawPoly (hDC,  40,  70, ALTERNATE, 0);
       DrawPoly (hDC, 170,  70, WINDING,  0);
       DrawPoly (hDC,  40, 150, ALTERNATE, 1);
       DrawPoly (hDC, 170, 150, WINDING,  1);

       EndPaint(hWnd, &ps);
       DeleteObject(hPen);
       break;

   case WM_DESTROY:
       PostQuitMessage(0);
       break;

   default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
   }
     return (0L);
     }

 void DrawPoly (hDC, xOrg, yOrg, nMode, nPt)
     HDC   hDC;
     short  xOrg, yOrg, nMode, nPt;
     {
     short  xOld, yOld;
     long  lView;
     /* Define points in figures */
     static POINT pts0[]={0,30, -30,-30, 30,0, -30,30,
        0,-30, 30,30, -30,0, 30,-30,
        0,30};

     static POINT pts1[]={0,-30, 25,25, -35,-10,
        35,-10, -25,25, 0,-30};

     xOld=LOWORD(lView=GetViewportOrg(hDC));
     yOld=HIWORD(lView);

     SetPolyFillMode(hDC, nMode);
     if (GetPolyFillMode(hDC)==ALTERNATE)
   TextOut(hDC, 40,20, "ALTERNATE",9);
     else
   TextOut(hDC, 40,20, "WINDING  ",9);

     /* Set selected origin */
     SetViewportOrg(hDC, xOrg, yOrg);

     /* Draw either Polygon 1 or 2 */
     if (nPt)
   Polygon(hDC, pts1, sizeof(pts1)/sizeof(POINT));
     else
   Polygon(hDC, pts0, sizeof(pts0)/sizeof(POINT));

     /* Restore old origin */
     SetViewportOrg(hDC, xOld, yOld);
     return;
     }


 GSUBMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GSUBMENU.C

 /*
  *
  * GetSubMenu
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  The WinMain proceeds to execute the GetSubMenu function
  *  if the user selects the "GetSubMenu" selection from the main menu bar.
  *  If the function call is successful, a message box is created which
  *  copies the menu string into a buffer.
  *
  */

 #include "windows.h"
   IDM_SUB      100   /* ID of the submenu.                          */
   N_MAX_COUNT   11   /* Maximum count of the characters of submenu. */
   SIZE_OUTBUFF  33   /* Size of the output buffer.                  */

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;
   HDC hDC;     /* Handle to the Display Context. */

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gsubmenu";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor      = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon          = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)"TestSubMenu"; /* Load menu name. */
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gsubmenu",
            (LPSTR) "GetSubMenu",
            WS_OVERLAPPEDWINDOW,           /* Use overlapped window.   */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            CW_USEDEFAULT,                 /* Use default coordinates. */
            (HWND)NULL,
            LoadMenu(hInst, (LPSTR)"TestSubMenu"),  /* Load submenu.   */
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0,0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    } /* while */


 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    char szbuf[N_MAX_COUNT];        /* Buffer for submenu string.   */
    char szoutbuf[SIZE_OUTBUFF];    /* Buffer for output.           */
    short int nCopied;              /* Number of characters copied. */
    HMENU hSubMenu;                 /* Handle to the submenu.       */

    switch (identifier) {
     case WM_COMMAND:
        switch (wParam) {
        case IDM_SUB:              /* If the submenu is selected,         */
              hSubMenu = GetSubMenu(GetMenu(hWnd), 0); /* Get the submenu. */
              if (hSubMenu == NULL)
                 {                  /* If the submenu is invalid,          */
                 MessageBox(hWnd,   /*  display a error message box.       */
                            (LPSTR)"No Popup Menu Exists Here!",
                            (LPSTR)"ERROR!!!",
                            MB_OK | MB_ICONEXCLAMATION);
                 break;             /* And stop here.                      */
                 };                 /* Otherwise, get the menu string by posit
              nCopied = GetMenuString(hSubMenu,
                                      0,
                                      (LPSTR)szbuf,
                                      N_MAX_COUNT,
                                      MF_BYPOSITION);
              if (nCopied == 0)   /* and issue an error message if fails.   */
                 {
                 MessageBox(hWnd,
                            (LPSTR)"GetMenuString Failed!",
                            (LPSTR)"MF_BYPOSITION",
                            MB_OK | MB_ICONEXCLAMATION);
                 break;
                 }
              else       /* Otherwise, display success through message box. */
                 {
                 sprintf(szoutbuf,
                         "%s%s%s",
                         "The SubMenu is '",
                         szbuf,
                         "'");
                 MessageBox(hWnd,
                            (LPSTR)szoutbuf,
                            (LPSTR)"GetSubMenu",
                            MB_OK);
                 };
             break;
        }

     default:
        return(DefWindowProc(hWnd, identifier, wParam, lParam));
        break;

    }

    return(0L);

 }


 GSYSCOLR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\GSYSCOLR.C

 /*
  *
  * GetSysColor
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetSysColor function is executed with the COLOR_BACKGROUND index.
  *  The RGB color is returned and displayed in a message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gsyscolr";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gsyscolr",
            (LPSTR) "GetSysColor",          /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[40];   /* Output buffer       | mouse button, then   */
        DWORD dwclr;  /* RGB color of background | establish needed     */
        unsigned short bRed, bGreen, bBlue;     /* variables and call   */
        dwclr = GetSysColor(COLOR_BACKGROUND);  /* the GetSysColor      */
        bRed = GetRValue(dwclr);                /* (with the individual */
        bGreen = GetGValue(dwclr);              /* colors separated to  */
        bBlue = GetBValue(dwclr);               /* different variables) */
       sprintf(szbuf,                          /* function.  Capture   */
           "%s%u%s%u%s%u%s\0",                  /* the RGB information  */
           "The Background Color is RGB(",      /* in a zero terminated */
          bRed, ",", bGreen, ",", bBlue, ")."); /* buffer.             */
       MessageBox(hWnd,                        /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetSysColor",        /* so that the user can */
                  MB_OK);                      /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GSYSMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\GSYSMENU.C

 /*
  *
  *   This program demonstrates the use of the GetSystemMenu() function.
  *   GetSystemMenu() returns a handle to the system menu of the specified
  *   Window. GetSystemMenu() is called in WinMain and then the handle
  *   returned by GetSystemMenu() is used to add a "Get....." option to
  *   the system menu.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 #define IDS_MY_OPTION 99

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"GetSystemMenu";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!HelloInit( hInstance ))
   return (FALSE);

     hWnd = CreateWindow((LPSTR)"GetSystemMenu",
       (LPSTR)"GetSystemMenu()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

 /*** retrieve the system menu as it currently exists ***/
     hMenu = GetSystemMenu(hWnd, FALSE);

 /*   Insert "Get....." into system menu   */
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)"Get.....", IDS_MY_OPTION, MF_APPEND | MF_STR

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
   case IDS_MY_OPTION:
       MessageBox(NULL,
            (LPSTR)"'Get.....' option chosen",
            (LPSTR)"System Menu:",
            MB_OK);
       break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
   BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
   TextOut(ps.hdc,
     5,
     5,
     (LPSTR)"The system menu has had an option added to it ('Get.....')",
     (long)58);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GSYSMODE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MODAL\GSYSMODE.C

 /*
  *
  *
  *   This program demonstrates the use of the GetSysModalWindow() function.
  *   GetSysModalWindow(). GetSysModalWindow() returns a handle to a system
  *   modal window if one exists.
  *
  *   Windows Version 2.0 function demonstration application
  *
  */

 #include "windows.h"

 HWND hSysModalWnd;

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName  = (LPSTR)"min";
     pHelloClass->lpszClassName  = (LPSTR)"SetSysModalWindow";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"SetSysModalWindow",
       (LPSTR)"SetSysModalWindow()",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     MessageBox(NULL,
          (LPSTR)"I'm a system modal message box",
          (LPSTR)"HI!",
          MB_SYSTEMMODAL);

     hSysModalWnd = GetSysModalWindow();

     if (hSysModalWnd)
   DestroyWindow(hSysModalWnd);
     else
   MessageBox(NULL,
        (LPSTR)"not found",
        (LPSTR)"system modal window...",
        MB_OK);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_COMMAND:

 /*** make "hWnd" system modal ***/
   SetSysModalWindow(hWnd);

   break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
   BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
   TextOut(ps.hdc,
     5,
     5,
     (LPSTR)"To make this window system modal, click on the menu",
     (long)51);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 GSYSMTRX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GSYSMTRX.C

 /*
  *
  * GetSystemMetrics
  *
  * This program demonstrates the use of the GetSystemMetrics function
  *  by checking to see if the debugging version of Windows is installed.
  *  If the user couble clicks the right mouse button, a message box
  *  is displayed telling if the debugging version of Windows has been
  *  installed.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gsysmtrx";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gsysmtrx",
            (LPSTR) "GetSystemMetrics",     /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[40];   /* Output buffer       | mouse button, then   */
        int iValue;   /* 0 if no debug, !0 if so | establish needed     */
                                                /* variables and call   */
        iValue = GetSystemMetrics(SM_DEBUG);    /* the GetSystemMetrics */
        if (iValue == 0)                        /* function.  Capture   */
           sprintf(szbuf, "%s%s%s\0",           /* debug information    */
                   "The Debugging Version ",     /* in a zero terminated */
                   "of Windows is NOT ",         /* buffer.              */
             "installed.");
        else
           sprintf(szbuf, "%s%s%s\0",
                   "The Debugging Version ",
                   "of Windows is ",
                   "installed.");

       MessageBox(hWnd,                   /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetSystemMetrics",   /* so that the user can */
                  MB_OK);                 /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTEMPDRV.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\I_O\GTEMPDRV.C

 /*
  *
  * GetTempDrive
  *
  *  This program demonstrates the use of the GetTempDrive function
  *  by returning the drive letter of the drive which can provide the
  *  best access time during disk operations involving a temporary file.
  *
  */

 #include "windows.h"

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
    char chBestDrive;                /* Drive Letter of the best           */
                                     /*  performance drive in system.      */
    char szbuf[80];                  /* Output buffer.                     */

    MessageBox(NULL,
         (LPSTR)"Hit OK to return the highest \
 performance drive in the system \
 for temp files.",
               (LPSTR)"Drive Test",
               MB_OK);

    chBestDrive = GetTempDrive('A'); /* Get the temp drive.                */

    sprintf(szbuf, "%s%c%s\0",       /* Set up report in output buffer.    */
            "Drive ", chBestDrive,
      ": is the best performance drive in the system \
 for temporary files.");

    MessageBox(NULL,                 /* Show the user which drive is best. */
               szbuf,
               (LPSTR)"GetTempDrive",
               MB_OK);

 } /* WinMain */


 GTICKCNT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\GTICKCNT.C

 /*
  *
  * GetTickCount
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTickCount function is executed.  The time since system startup
  *  is returned and displayed in a message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtickcnt";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtickcnt",
            (LPSTR) "GetTickCount",         /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[80];   /* Output buffer       | mouse button, then   */
        DWORD dwCnt;  /* No. of ms since startup | establish needed     */
                                                /* variables and call   */
        dwCnt = GetTickCount();                 /* the GetTickCount     */
                                                /* function.  Capture   */
       sprintf(szbuf,                          /* the time information */
           "%s%s%lu%s\0",                        /* in a zero terminated */
           "The No. of Milliseconds since",     /* buffer.              */
          " system startup is ", dwCnt, ".");

        MessageBox(hWnd,                        /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetTickCount",       /* so that the user can */
                  MB_OK);                      /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTMPFNAM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\GTMPFNAM.C

 /*
  *
  * GetTempFileName
  *
  * This program demonstrates the use of the GetTempFileName function
  *  by creating a filename called "temp####" in the directory pointed
  *  to by the TEMP environment varible.  The #### stands for a four
  *  digit number based upon the current system time (Windows generates
  *  this number).  The file is created and then closes the file.
  *
  */

 #include "windows.h"

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
    char szTmpFle[80];                  /* Buffer for Temp file name.      */
    char szOutBufr[80];                 /* Output Buffer.                  */
    int iFNumb;                         /* Unique number Windows provides. */

    MessageBox(NULL,                    /* Prep the user with a message.   */
               (LPSTR)"About to create Temporary File.",
               (LPSTR)"GetTempFileName Test",
               MB_OK);

     /* Get the new Temporary File Name, create, then close the file. */

    iFNumb = GetTempFileName((BYTE)'D',
                             (LPSTR)"TMP",
                             (WORD)0,
                             (LPSTR)szTmpFle);

     /* Place the unique number (last four characters of filename)    */
     /* into an output buffer for display in a message box.           */

    sprintf(szOutBufr,
            "%s%4i\0",
            "The file number is: ",
            iFNumb);

     /* Output the unique file number in a message box for clarity.   */

    MessageBox(NULL,
               (LPSTR)szOutBufr,
               (LPSTR)"Allocated File Number.",
               MB_OK);

     /* Put the complete path and file name into an output buffer.    */

    sprintf(szOutBufr, "%s%s%s\0",
            "The temporary filename is ",
            szTmpFle, ".");

     /* Output the complete file name in a message box for clarity.   */

    MessageBox(NULL, (LPSTR)szOutBufr,
               (LPSTR)"GetTempFileName",
               MB_OK);

 } /* WinMain */


 GTXTCHX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GTXTCHX.C

 /*
  *
  * GetTextCharacterExtra
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTextCharacterExtra function is executed.  The intercharacter
  *  spacing is returned and displayed in a message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtxtchx";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtxtchx",
            (LPSTR) "GetTextCharacterExtra", /* Create a window.         */
            WS_OVERLAPPEDWINDOW,             /* Make it overlapped.      */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Show Intercharacte
                 63, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double    */
        {                                       /* clicks on the right   */
        char szbuf[80];   /* Output buffer       | mouse button, then    */
        short sIntSpacing;                      /* variables and call    */
        HDC hDC; /* Handle to display Context. */

        hDC = GetDC(hWnd);                      /* (after getting DC)    */
        sIntSpacing = GetTextCharacterExtra(hDC); /* GetTextCharacterExtra */
                                                /* (with the display     */
                                                /* context of the top    */
                                                /* level window.         */
       sprintf(szbuf,                          /* Capture the interchar */
           "%s%i%s\0",                          /* spacing information   */
           "Current Intercharacter Spacing = ", /* in a zero terminated  */
          (int)sIntSpacing, ".");              /* buffer.               */
       MessageBox(hWnd,                        /* Output the buffer in  */
                   (LPSTR)szbuf,                /* a message box format  */
                   (LPSTR)"GetTextCharacterExtra", /* so that the user   */
                  MB_OK);                      /* can have a readable   */
                                                /* and useful format.    */

        SetTextCharacterExtra(hDC, 10);

        MessageBox(hWnd, (LPSTR)"Set the Intercharacter Spacing to 10.",
                   (LPSTR)"Setting = 10",
                   MB_OK);

        sIntSpacing = GetTextCharacterExtra(hDC);

        sprintf(szbuf,
           "%s%i%s\0",
           "New Intercharacter Spacing = ",
          (int)sIntSpacing, ".");
       MessageBox(hWnd,
                   (LPSTR)szbuf,
                   (LPSTR)"GetTextCharacterExtra",
                  MB_OK);
        }
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTXTCOLR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GTXTCOLR.C

 /*
  *
  * GetTextColor
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTextColor function is executed with the HDC of the top level window.
  *  The RGB color is returned and displayed in a message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtxtcolr";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtxtcolr",
            (LPSTR) "GetTextColor",         /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[40];   /* Output buffer       | mouse button, then   */
        DWORD dwclr;  /* RGB color of text       | establish needed     */
        unsigned short bRed, bGreen, bBlue;     /* variables and call   */
        HDC hDC; /* Display Context Handle. */

        hDC = GetDC(hWnd);                      /* (after getting DC)   */
        dwclr = GetTextColor(hDC);              /* the GetSysColor      */
        bRed = GetRValue(dwclr);                /* (with the individual */
        bGreen = GetGValue(dwclr);              /* colors separated to  */
        bBlue = GetBValue(dwclr);               /* different variables) */
       sprintf(szbuf,                          /* function.  Capture   */
           "%s%u%s%u%s%u%s\0",                  /* the RGB information  */
           "The Text Color is RGB(",            /* in a zero terminated */
          bRed, ",", bGreen, ",", bBlue, ")."); /* buffer.             */
       MessageBox(hWnd,                        /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetTextColor",       /* so that the user can */
                  MB_OK);                      /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTXTEXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GTXTEXT.C

 /*
  *
  * GetTextExtent
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTextExtent function is executed with the HDC of the top level
  *  window and the text "Test Text.".  The extents are returned in a
  *  message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;         /* Handle to the Instance.            */
 static HWND hWnd;            /* Handle to the Window.              */
 static LPSTR lpTesttxt;      /* Long Pointer to Test Text String.  */

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   lpTesttxt = (LPSTR)"Test Text.";

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtxtext";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtxtext",
            (LPSTR) "GetTextExtent",        /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Prompt text.    */
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 275, 75);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC, lpTesttxt, 10,
                  (LPRECT)&rRect, DT_SINGLELINE);     /* Test Text.      */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[80];   /* Output buffer.      | mouse button, then   */
        DWORD dwTxtExts;  /* Extents - test text.| establish needed     */
                                                /* variables and call   */
        HDC hDC; /* Display Context Handle. */

        hDC = GetDC(hWnd);                      /* (after getting DC)   */
        dwTxtExts = GetTextExtent(hDC,
                                  lpTesttxt, 10); /* the GetTextExtent  */
       sprintf(szbuf,                          /* function.  Capture   */
           "%s%i%s%i%s\0",                      /* the Ext information  */
           "The Text Extents are (",            /* in a zero terminated */
          (int)HIWORD(dwTxtExts), ",",         /* buffer.             */
           (int)LOWORD(dwTxtExts), ").");
       MessageBox(hWnd,                        /* Output the buffer in */
                   (LPSTR)szbuf,                /* a message box format */
                   (LPSTR)"GetTextExtent",      /* so that the user can */
                  MB_OK);                      /* have a readable and  */
        }                                       /* useful format.       */
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTXTFACE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GTXTFACE.C

 /*
  *
  * GetTextFace
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTextFace function is executed with the HDC of the top level
  *  window and default font.  The facename is returned in a message
  *  box.  If an error occurs, a message box is also returned.
  *
  */

 #include "windows.h"

 #define BUF_SIZE 80

 /* Global Variables */
 static HANDLE hInst;         /* Handle to the Instance.            */
 static HWND hWnd;            /* Handle to the Window.              */

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtxtface";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtxtface",
            (LPSTR) "GetTextFace",          /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Prompt text.    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[BUF_SIZE]; /* Output buffer.  | mouse button, then   */
                              /*                 | establish needed     */
        char szFacename[BUF_SIZE]; /* Facename Buffer.                  */
        short sBytesCopied; /* Bytes copied.     | variables and call   */
        HDC hDC; /* Display Context Handle. */

        hDC = GetDC(hWnd);                      /* (after getting DC)   */
        sBytesCopied = GetTextFace(hDC, BUF_SIZE,
                            (LPSTR)szFacename); /* the GetTextFace fn.  */

        if (sBytesCopied == 0)                  /* If error, issue a    */
           {                                    /* message box.         */
              MessageBox(hWnd,
                         (LPSTR)"No Bytes Copied!!!",
                         (LPSTR)"GetTextFace",
                         MB_OK | MB_ICONEXCLAMATION);
              break;
           }
        else
           {
          sprintf(szbuf,                       /* Now its OK; capture  */
              "%s%s%s\0",                       /* the Face information */
              "The Facename is '",               /* in a zero terminated */
             szFacename, "'.");                 /* buffer.              */

           MessageBox(hWnd,                     /* Output the buffer in */
                      (LPSTR)szbuf,             /* a message box format */
                      (LPSTR)"GetTextFace",     /* so that the user can */
                     MB_OK);                   /* have a readable and  */
            };                                  /* useful format.       */
        }
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GTXTMTRX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\GTXTMTRX.C

 /*
  *
  * GetTextMetrics
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  GetTextMetrics function is executed with the HDC of the top level
  *  window and the current font.  The width and height are returned in a
  *  message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;         /* Handle to the Instance.            */
 static HWND hWnd;            /* Handle to the Window.              */

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"gtxtmtrx";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "gtxtmtrx",
            (LPSTR) "GetTextMetrics",        /* Create a window.         */
            WS_OVERLAPPEDWINDOW,            /* Make it overlapped.      */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            CW_USEDEFAULT,                  /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {
    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Conduct Test.",
                 48, (LPRECT)&rRect, DT_SINGLELINE);  /* Prompt text.    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double   */
        {                                       /* clicks on the right  */
        char szbuf[80];   /* Output buffer.      | mouse button, then   */
        TEXTMETRIC *strTM; /* Extents - test text.| establish needed    */
        BOOL bGotem;      /* Boolean success flg | variables and call   */
        HDC hDC;      /* Display Context Handle. | the GetTextMetrics   */
        HANDLE hLMem;     /* Local Memory for the Text Metrics.         */

           /* Allocate the local memory for the Text Metrics. */

        hLMem = LocalAlloc(LMEM_DISCARDABLE | LMEM_MOVEABLE,
                           sizeof(TEXTMETRIC));
        if (hLMem == NULL)   /* If error, then complain. */
           {
           MessageBox(hWnd, (LPSTR)"Could Not allocate Local Memory!!!",
                      (LPSTR)"ERROR!!!", MB_OK | MB_ICONEXCLAMATION);
           break;
           };

           /* Lock the local memory. */

        strTM = (TEXTMETRIC *)LocalLock(hLMem);

        if (strTM == NULL)   /* If error, then complain. */
           {
           MessageBox(hWnd, (LPSTR)"Could Not lock Local Memory!!!",
                      (LPSTR)"ERROR!!!", MB_OK | MB_ICONEXCLAMATION);
           break;
           };

        hDC = GetDC(hWnd);                      /* (after getting DC)   */

           /* Get the Text Metrics of the current Font. */

        bGotem = GetTextMetrics(hDC, (LPTEXTMETRIC)strTM);

        if (bGotem == NULL)   /* If the GetTextMetrics fails, then complain. *
           {
           MessageBox(hWnd,
              (LPSTR)"Did Not Get The Text Metrics!!!",
              (LPSTR)"ERROR!!!", MB_OK | MB_ICONEXCLAMATION);
           break;
           }
        else
           {
          sprintf(szbuf,                       /* Otherwise, capture   */
                   "%s%s%i%s%i%s\0",            /* the Ext information  */
                   "The Text Metrics ",         /* in a zero terminated */
                   "<height,weight> are (",     /* buffer.             */
                  (int)strTM->tmHeight, ",",
                   (int)strTM->tmWeight, ").");

          MessageBox(hWnd,                     /* Output the buffer in */
                      (LPSTR)szbuf,             /* a message box format */
                      (LPSTR)"GetTextMetrics",  /* so that the user can */
                     MB_OK);                   /* have a readable and  */
           };                                   /* useful format.       */
        LocalUnlock(hLMem);  /* Unlock the local memory. */
        LocalFree(hLMem);    /* Free the local memory.   */
        };
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 GUPDRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\GUPDRECT.C

 /*
 Date: 7/11/88
 Function(s) demonstrated in this program: GetUpdateRect
 Compiler version: C 5.1
 Description: This program paints the client area red, make the window a icon,
              and then restores the window to it original size. By doing this
              it creates a update region. With the update region, the function
              GetUpdateRect is used to find the smallest rectangle around the
              update region. Then the program display the coordinates of the
              update rectangle.
 */

 #include <windows.h>
 #include <stdio.h>
 #include "gupdrect.h"

 static char szFuncName [] = "GetUpdateRect";
 static char szAppName [] = "GUPDRECT";

 int PASCAL WinMain ( hInstance, hPrevInstance, lpszCmdLine, nCmdShow )
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
 {
      HWND        hWnd;
      WNDCLASS    wndclass;
      MSG         msg;
      HMENU       hMenu;

      if (!hPrevInstance) {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc;
           wndclass.cbClsExtra    = 0;
           wndclass.cbWndExtra    = 0;
           wndclass.hInstance     = hInstance;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
           wndclass.lpszMenuName  = "GUDR";
           wndclass.lpszClassName = szFuncName;

           if (!RegisterClass (&wndclass))
                return FALSE;
           }

      hMenu = LoadMenu ( hInstance, "GUDR" );


      hWnd = CreateWindow (szFuncName,           /* window class name       */
                     szAppName,                  /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     hMenu,                      /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL);                      /* create parameters       */

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

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam);
 }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
    HDC         hDC;
    PAINTSTRUCT ps;
    RECT        rectUpdateRect;
    RECT        rectClientRect;
    HBRUSH      hSolidBrush;
    BOOL        bfGotUpdateRect;
    int         nIndex;
    char        szBuffer [100];

    switch(iMessage)
    {
    case WM_INITMENU:
       InvalidateRect ( hWnd, (LPRECT)NULL, TRUE );
       break;
     case WM_COMMAND:
        switch ( wParam )
           {
           case IDM_BOX:
              GetClientRect ( hWnd, (LPRECT)&rectClientRect );

              hDC = GetDC ( hWnd );
              hSolidBrush = CreateSolidBrush ( 0xFF0000 );
              FillRect ( hDC, (LPRECT)&rectClientRect, hSolidBrush );

              ShowWindow ( hWnd, SW_SHOWMINIMIZED );
              ShowWindow ( hWnd, SW_SHOWNORMAL );

              bfGotUpdateRect = GetUpdateRect ( hWnd, (LPRECT)&rectUpdateRect,
                 FALSE );

              if ( bfGotUpdateRect == TRUE )
                 {
                 sprintf ( szBuffer, "%s %d%s %d%s %d%s %d%s",
                    "Update rectangle .top is", rectUpdateRect.top,
                    ",\nupdate rectangle .bottom is", rectUpdateRect.bottom,
                    ",\nupdate rectangle .left is", rectUpdateRect.left,
                    ",\nand update rectangle .right is", rectUpdateRect.right,
                    "." );
                 MessageBox ( hWnd, (LPSTR)szBuffer, (LPSTR)szFuncName,
                    MB_OK );
                 }
              else
                 MessageBox ( hWnd, (LPSTR)"Update rectangle is empty.",
                    (LPSTR)szFuncName, MB_OK );

              ReleaseDC ( hWnd, hDC );
              break;
           default :
              return DefWindowProc (hWnd, iMessage, wParam, lParam);
              break;
           }
        break;
      case WM_DESTROY:
        PostQuitMessage(0);
        break;
      default:
        return DefWindowProc (hWnd, iMessage, wParam, lParam);
      return (0L);
    }
 }


 HELLO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\STACK\HELLO.C

 /*  Hello.c
     Hello Application
     Windows Toolkit Version 2.03
     Copyright (c) Microsoft 1985,1986,1987,1988 */

 #include "windows.h"
 #include "hello.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[15];
 int  MessageLength;

 static HANDLE hInst;
 FARPROC lpprocAbout;

 void PASCAL InitStackUsed();
 int  PASCAL ReportStackUsed();

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:
             break;
         case WM_COMMAND:
             EndDialog(hDlg, TRUE);
             break;
         default:
             return FALSE;
             break;
         }
     return(TRUE);
 }


 void HelloPaint( hDC )
 HDC hDC;
 {
   TextOut( hDC, 10, 10, "Determines stack size.", 22 );
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon          = LoadIcon( hInstance, MAKEINTRESOURCE(HELLOI
     pHelloClass->lpszMenuName   = (LPSTR)szAppName;
     pHelloClass->lpszClassName  = (LPSTR)szAppName;
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     InitStackUsed();

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!HelloInit( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szMessage, 15 );
         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Bind callback function with module instance */
     lpprocAbout = MakeProcInstance( (FARPROC)About, hInstance );

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;
     char  buf[20];
     int   iStack;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_COMMAND:
         switch (wParam)
         {
         case IDMCHECK:
                iStack = ReportStackUsed();
                itoa ( iStack, buf, 10);
                MessageBox (hWnd, buf,"Stack =", MB_OK );
             break;

         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         HelloPaint( ps.hdc );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 HELLO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MODELESS\HELLO.C

 /*  Hello.c
     Hello Application
     Windows Version 1.01
     Copyright (c) Microsoft 1985

 This application has been  revised  to  demonstrate  the  coding
 differences between the two Dialog boxes:
    MODAL, created  using DialogBox and
    MODELESS, created using CreateDialog.
 The  application  starts  out by having the user select the "GO"
 menu item which creates the "First Dialog"  and  then  the  DEMO
 button  then  creates  the "Second Dialog".  The "Second Dialog"
 then allows you to push some buttons and process them.

 To point out the differences in coding,  there are  "#ifdef"  to
 allow  you  to  compile using the desired method and to visually
 see what needs to be done when using one method over the  other.
 This  information  is  an  expanded implementation of the sample
 code on pages 169-173 of the Programming Guide.  The default  is
 set to compile using MODAL dialog boxes.  If you want to compile
 using the MODELESS dialog boxes, change "MODAL" to "XMODAL".*/

  XMODAL /* default */

 #include "windows.h"
 #include "hello.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[15];
 int  MessageLength;

 #ifdef MODAL
 #else
 HWND  hDlgWnd1;
 HWND  hDlgWnd2;
 #endif
 static  HANDLE hInst;
 FARPROC lpprocAbout;
 FARPROC lpprocFirstDlg;
 FARPROC lpprocSecondDlg;

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL     FirstDlg(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL    SecondDlg(HWND, unsigned, WORD, LONG);

 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     if (message == WM_COMMAND) {
         EndDialog( hDlg, TRUE );
         return TRUE;
         }
     else if (message == WM_INITDIALOG)
         return TRUE;
     else return FALSE;
 }


 void HelloPaint( hDC )
 HDC hDC;
 {
     TextOut( hDC, (short)10, (short)10,
 #ifdef MODAL
            (LPSTR)"DialogBox = Modal",(short)17 );
 #else
            (LPSTR)"CreateDialog = Modeless",(short)23 );
 #endif
 }

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon          = LoadIcon( hInstance, (LPSTR)szAppName );
     pHelloClass->lpszMenuName   = (LPSTR)szAppName;
     pHelloClass->lpszClassName  = (LPSTR)szAppName;
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     BOOL  bResult;
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
         if (!HelloInit( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szMessage, 15 );
         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                         WS_TILEDWINDOW,
                         0,    /*  x - ignored for tiled windows */
                         0,    /*  y - ignored for tiled windows */
                         0,    /* cx - ignored for tiled windows */
                         0,    /* cy - ignored for tiled windows */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Bind callback function with module instance */
         lpprocAbout = MakeProcInstance( (FARPROC)About,     hInstance );
      lpprocFirstDlg = MakeProcInstance( (FARPROC)FirstDlg,  hInstance );
     lpprocSecondDlg = MakeProcInstance( (FARPROC)SecondDlg, hInstance );

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
 #ifdef MODAL
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }
 #else
     /* The following can be rewritten in many ways, but was made
        for clairity and for easy modification.
        Since this program does not use an Accelerator Table the
        code has been commented out.  I thought I should put it
        in for completness.  */

     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         bResult = NULL; /* default is that the message has not been processed
         if (hDlgWnd1 != NULL)
            bResult = IsDialogMessage(hDlgWnd1, (LPMSG)&msg);
         if (hDlgWnd2 != NULL)
            bResult = IsDialogMessage(hDlgWnd2, (LPMSG)&msg);
      /* if (!bResult)  /* message not processed by above dialog(s) */
      /*    bResult = TranslateAccelerator(hWnd, hAccelTable, (LPMSG)&msg );
      */
         if (!bResult) {  /* the parent will get the message */
              TranslateMessage((LPMSG)&msg);
              DispatchMessage((LPMSG)&msg);
         } /* end if */
     } /* end while */
 #endif
     return (int)msg.wParam;
 }


 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_CREATE:
 #ifdef MODAL
 #else
     hDlgWnd1 = NULL;  /* initialize the first time through */
     hDlgWnd2 = NULL;  /* initialize the first time through */
 #endif
         break;

     case WM_COMMAND:
 #ifdef MODAL
         DialogBox( hInst, MAKEINTRESOURCE(FIRSTDIALOG),
                    hWnd, lpprocFirstDlg);
 #else
         hDlgWnd1 = CreateDialog( hInst, MAKEINTRESOURCE(FIRSTDIALOG),
                                  hWnd, lpprocFirstDlg);
 #endif
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         HelloPaint( ps.hdc );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }

 /**********************************************************
                   First  Dialog
 ***********************************************************/
 BOOL FAR PASCAL FirstDlg(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
 {
     switch (message){
     case WM_INITDIALOG:
         return TRUE;

     case WM_COMMAND:
         switch (wParam)
         {
         case IDDINSERT:
 #ifdef MODAL
              DialogBox(hInst, MAKEINTRESOURCE(SECONDDIALOG),
            hDlg, lpprocSecondDlg);
              /* please note that the Dialog in the RC file does
                 NOT have the WS_VISIBLE attribute set which will
                 allow for keyboard processing BEFORE the dialog
                 is displayed.                                   */
 #else
        hDlgWnd2 = CreateDialog(hInst, MAKEINTRESOURCE(SECONDDIALOG),
              hDlg, lpprocSecondDlg);
              /* ShowWindow is needed here because the dialog
                 style doesn't have WM_VISIBLE bit set.  */
              ShowWindow(hDlgWnd2,SHOW_OPENWINDOW);
 #endif
             break;
         case IDDCANCEL:
 #ifdef MODAL
       EndDialog(hDlg, TRUE);
 #else
       DestroyWindow(hDlg);
       hDlgWnd1 = NULL; /* clear because this is used in the input loop */
 #endif
       break;

         default:
             return FALSE;
         }
         break;

     default:
         return FALSE;
     }
     return TRUE;
 }


 /**********************************************************
                   Second Dialog
 ***********************************************************/
 BOOL FAR PASCAL SecondDlg(hDlg, message, wParam, lParam)
 HWND     hDlg;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
 {

   switch (message){
      case WM_INITDIALOG:
       /* Modify the text strings. */
    SetDlgItemText( hDlg, IDDTXT1,
              (LPSTR)"Use the 'TAB' key to move around.");
    SetDlgItemText( hDlg, IDDTXT2,
              (LPSTR)"Select the button desired.");

       /* Modify the button text. */
    SetDlgItemText( hDlg, IDDABORT, (LPSTR)"ONE");
    SetDlgItemText( hDlg, IDDRETRY, (LPSTR)"TWO");
    SetDlgItemText( hDlg, IDDIGNORE,(LPSTR)"THREE");
    SetDlgItemText( hDlg, IDDOK,   (LPSTR)"FOUR");

       /* Disable the 2nd button */
    EnableWindow( GetDlgItem(hDlg, IDDRETRY), FALSE );

          break;

      case WM_COMMAND:
          switch (wParam)
          {
            case IDDABORT:
        MessageBox( hDlg,(LPSTR)"One",(LPSTR)"Button Selected",MB_OK);
              break;
            case IDDRETRY:
        MessageBox( hDlg,(LPSTR)"Two",(LPSTR)"Button Selected",MB_OK);
              break;
            case IDDIGNORE:
        MessageBox( hDlg,(LPSTR)"Three",(LPSTR)"Button Selected",MB_OK);
              break;
            case IDDOK:
        MessageBox( hDlg,(LPSTR)"Four",(LPSTR)"Button Selected",MB_OK);
              break;
      default: ;  /* nothing */
     break;
    }  /* end switch */

     case WM_CLOSE:

 #ifdef MODAL
    EndDialog(hDlg, TRUE);
 #else
    DestroyWindow(hDlg);
    hDlgWnd2 = NULL; /* clear because this is used in the input loop */
 #endif

   break;

      default:
          return FALSE;
    }
    return TRUE;
 }


 HIDE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\HIDE.C

 /*
  *
  *  HideCaret
  *
  *  This program demonstrates the use of the HideCaret function. The
  *  HideCaret function removes the caret from the specified window.
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pClass;

   pClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));
   pClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pClass->lpszMenuName   = (LPSTR)NULL;
   pClass->lpszClassName  = (LPSTR)"Window";
   pClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pClass->hInstance      = hInstance;
   pClass->style          = CS_HREDRAW | CS_VREDRAW;
   pClass->lpfnWndProc    = DefWindowProc;

   if (!RegisterClass ( (LPWNDCLASS)pClass))
     return FALSE;

   LocalFree ( (HANDLE) pClass);
   return TRUE;        /* Initialization succeeded */
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   HWND         hWnd;                /* Handle to the parent window    */

   WinInit (hInstance);

   hWnd = CreateWindow ( (LPSTR)"Window",
       (LPSTR)"Sample Window",
       WS_OVERLAPPEDWINDOW,
       20, 20, 400, 200,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
  );

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   CreateCaret (hWnd, NULL, 8, 12);
   SetCaretPos (50, 50);
   ShowCaret (hWnd);
   MessageBox (hWnd, (LPSTR)"Here is the caret",
       (LPSTR)" ", MB_OK);
   MessageBox (hWnd, (LPSTR)"The caret is going to be hid",
       (LPSTR)"WARNING", MB_OK);
 /** hide the caret **/
   HideCaret (hWnd);
 /** output message box so application does not end before user **/
 /** can see that the caret is gone                             **/
   MessageBox (hWnd, (LPSTR)"It's gone!", (LPSTR)" ", MB_OK);

   return 0;
   }


 HILITE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\HILITE.C

 /*
  *   HiliteMenuItem
  *
  *   This program demonstrates the use of the HiliteMenuItem function. The
  *   HiliteMenuItem function hilites or removes hiliting from an item in a
  *   menu. In this program, the 4th item in the system menu was hilited in
  *   the WinMain procedure.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName     = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   HelloInit (hInstance);
   hWnd = CreateWindow ( (LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
  );

 /*** get the handle to the system menu *********************************/
   hMenu = GetSystemMenu (hWnd, FALSE);

 /*** hilite the 4th item in the system menu *****************************/
   HiliteMenuItem (hWnd, hMenu, 3, MF_BYPOSITION | MF_HILITE);

 /* Make window visible according to the way the app is activated */
   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   MessageBox (hWnd, (LPSTR)" ...the fourth menu-item will be hilited.",
       (LPSTR)"  Click on the System Menu and...  ", MB_OK);

 /* Polling messages from event queue */
   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }

   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }


 ICLIPREC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\ICLIPREC.C

 /*
  *
  *  IntersectClipRect
  *
  *  This program demonstrates the use of the IntersectClipRect function.
  *  IntersectClipRect creates a new clipping region for the specified DC
  *  by taking the intersection of the current clipping region and the
  *  rectangle represented by the four values sent it. IntersectClipRect
  *  is called from FunctionDemonstrated in this sample application.
  */

 #include <windows.h>
 HWND hWnd;

 BOOL FAR PASCAL InitMaster (HANDLE, HANDLE, int);
 long FAR PASCAL MasterWindowProc (HANDLE, unsigned, WORD, LONG);
 void FAR PASCAL FunctionDemonstrated ();

 /***********************   main procedure   *******************************/

 int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;

   InitMaster (hInstance, hPrevInstance, cmdShow);

   FunctionDemonstrated ();

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   exit (msg.wParam);
   }


 /*******************************   initialization   ***********************/

 BOOL FAR PASCAL InitMaster (hInstance, hPrevInstance, cmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;
   {
   WNDCLASS  wcMasterClass;
   HMENU     hMenu;

   wcMasterClass.lpszClassName = (LPSTR) "Master";
   wcMasterClass.hInstance     = hInstance;
   wcMasterClass.lpfnWndProc   = MasterWindowProc;
   wcMasterClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcMasterClass.hIcon         = NULL;
   wcMasterClass.lpszMenuName  = (LPSTR) NULL;
   wcMasterClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcMasterClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcMasterClass.cbClsExtra    = 0;
   wcMasterClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcMasterClass);

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, "Execute Function", 100, MF_APPEND);

   hWnd = CreateWindow ( (LPSTR) "Master", (LPSTR) "IntersectClipRect",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL,hMenu , hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }

 /*********************   window procedure - process messages   *************/
 long    FAR PASCAL MasterWindowProc (hWnd, message, wParam, lParam)
 HWND        hWnd;
 unsigned    message;
 WORD      wParam;
 LONG        lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       if (wParam == 100)
         FunctionDemonstrated ();
       else
         return (DefWindowProc (hWnd, message, wParam, lParam));
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }

 /****************************   function demonstrated   ********************/

 void FAR PASCAL FunctionDemonstrated ()
   {
   HDC hDC = GetDC (hWnd);
   HRGN hRgn;     /* handle to first clipping region    */
   RECT ClientRect;
   POINT RectPoint[2];
   short  nNewClipRect;   /* return value from IntersectClipRect */

   GetClientRect (hWnd, (LPRECT) & ClientRect); /* load device coordinates */

   SetMapMode (hDC, MM_ANISOTROPIC);
   SetWindowOrg (hDC, 0, 0);
   SetWindowExt (hDC, 120, 120);
   SetViewportOrg (hDC, 0, 0);
   SetViewportExt (hDC, (short) ClientRect.right, (short) ClientRect.bottom);

   RectPoint[0].x = 0;
   RectPoint[0].y = 0;
   RectPoint[1].x = 100;
   RectPoint[1].y = 100;

   LPtoDP (hDC, (LPPOINT) & RectPoint[0].x, 2);

   hRgn = CreateRectRgn ( (short) RectPoint[0].x,
       (short) RectPoint[0].y,
       (short) RectPoint[1].x,
       (short) RectPoint[1].y);

   SelectClipRgn (hDC, hRgn);

   MessageBox (GetFocus (), (LPSTR)"into the first clipping region",
       (LPSTR)"I am about to do a TextOut and InvertRect...",
       MB_OK);

   TextOut (hDC, 0, 5,
       "THIS LINE HERE IS VERY LONG . WILL IT ALL BE SHOWN IN THE CLIPPING REG
       (short)75);
   InvertRect (hDC, (LPRECT) & ClientRect);

 /*** call IntersectClipRect with first clipping region and new coordinates **

   RectPoint[0].x = 5;
   RectPoint[0].y = 5;
   RectPoint[1].x = 20;
   RectPoint[1].y = 20;

   LPtoDP (hDC, (LPPOINT) & RectPoint[0].x, 2);

   nNewClipRect = IntersectClipRect (hDC,
       (short)RectPoint[0].x,
       (short)RectPoint[0].y,
       (short)RectPoint[1].x,
       (short)RectPoint[1].y);

   if (nNewClipRect == ERROR)
     MessageBox (GetFocus (), (LPSTR)"The DC sent IntersectClipRect is not val
         (LPSTR)NULL,
         MB_OK);

   MessageBox (GetFocus (), (LPSTR)"into the intersected clipping region",
       (LPSTR)"I am about to do a TextOut and InvertRect...",
       MB_OK);

   TextOut (hDC, 0, 15,
       "THIS LINE HERE IS VERY LONG . WILL IT ALL BE SHOWN IN THE CLIPPING REG
       (short)75);
   InvertRect (hDC, (LPRECT) & ClientRect);

   ReleaseDC (hWnd, hDC);
   DeleteObject (hRgn);

   return;
   }


 ICONTEST.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ICON\ICONTEST.C

 /*
 Date: 7/19/88
 Function(s) demonstrated in this program: SetResourceHandler
 Compiler version: 5.1
 Description: This example is taken from Application Note 12 (Windows "Icon"
              utility). The SetResourceHandler should only be used with
              user defined resources. In this example a generic bitmap is
              read through ICONLIB.LIB and ICONLIB.EXE (both of this files are
              need) and displayed in ICONTEST as an icon. The function
              SetResourceHandler is used to have the user defined function
              ResourceHandler setup the bitmap as an icon when the bitmap
              is loaded.
 */

 #include <windows.h>
 #include <stdio.h>
 #include "icontest.h"

 typedef struct {
     short   csHotX;
     short   csHotY;
     short   csWidth;
     short   csHeight;
     short   csWidthBytes;
     short   csColor;
     char    csBits[ 1 ];
     } CURSORSHAPE;

 typedef struct {
     short magic;
     CURSORSHAPE info;
     } CURSORFILEHEADER;

 typedef CURSORFILEHEADER FAR *LPCURSOR;

 static char szAppName [] = "ICONTEST" ;
 static char szFuncName [] = "SetResourceHandler" ;
 WORD hInst;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
     MSG        msg;
     WNDCLASS   wndclass;
     HWND       hWnd;
     HMENU      hMenu;

     if ( !hPrevInstance )
        {
        wndclass.style          = CS_HREDRAW | CS_VREDRAW;
        wndclass.lpfnWndProc    = WndProc;
        wndclass.cbWndExtra     = 0;
        wndclass.cbClsExtra     = 0;
        wndclass.hInstance      = hInstance;
        wndclass.hCursor        = LoadCursor( NULL, IDC_ARROW );
        wndclass.hIcon          = LoadIcon (NULL, IDI_APPLICATION);
        wndclass.hbrBackground  = GetStockObject( WHITE_BRUSH );
        wndclass.lpszMenuName   = "icontest";
        wndclass.lpszClassName  = szAppName;

       if ( !RegisterClass( &wndclass ) )
            return FALSE;
        }

     hMenu = LoadMenu( hInstance, (LPSTR)"icontest" );
     hInst = hInstance;

     hWnd = CreateWindow( szAppName,     /* window class name       */
             szFuncName,                 /* window caption          */
             WS_OVERLAPPEDWINDOW,        /* window style            */
             CW_USEDEFAULT,              /* initial x position      */
             0,                          /* initial y position      */
             CW_USEDEFAULT,              /* initial x size          */
             0,                          /* initial y size          */
             NULL,                       /* parent window handle    */
             hMenu,                      /* window menu handle      */
             hInstance,                  /* program instance handle */
             NULL );                     /* create parameters       */

     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     while ( GetMessage( ( LPMSG )&msg, NULL, 0, 0 ) )
        {
        TranslateMessage( ( LPMSG )&msg );
        DispatchMessage( ( LPMSG )&msg );
        }
     return( msg.wParam );
 }

 long FAR PASCAL WndProc( hWnd, iMessage, wParam, lParam )
 HWND       hWnd;
 unsigned   iMessage;
 WORD       wParam;
 LONG       lParam;
 {
     HDC          hDC;

     switch ( iMessage )
     {
     case WM_INITMENU:
        InvalidateRect ( hWnd, NULL, TRUE );
        break;

     case WM_CLOSE:
        DestroyWindow ( hWnd );
        break;

     case WM_DESTROY:
        PostQuitMessage( 0 );
        break;

     case WM_COMMAND:
        IconTestCommand ( hWnd, wParam );
        break;

     default:
         return ( DefWindowProc( hWnd, iMessage, wParam, lParam ) );
     }
     return( 0L );
 }

 /*
 **  ResourceHandler - routine to service "calculated" resources.
 **  In this case, Icons.
 **
 **  A resource handler can be installed for each resource TYPE.
 */

 HANDLE FAR PASCAL ResourceHandler( hRes, hResFile, hResIndex )
 HANDLE hRes;
 HANDLE hResFile;
 HANDLE hResIndex;
 {
     WORD       wSize;
     BYTE FAR   *lpIcon;
     int        nIndex;

     /* Process machine dependent ICON and CURSOR resources. */
     wSize = ( WORD )SizeofResource( hResFile, hResIndex );
     nIndex = 0;

     if ( !hRes )
        {
        if ( !( hRes = AllocResource( hResFile, hResIndex, 0L ) ) )
            return NULL;
        nIndex = -1;
        }

     while ( !( lpIcon = ( BYTE FAR * )GlobalLock( hRes ) ) )
     if ( !GlobalReAlloc( hRes, ( DWORD )wSize, 0 ) )
         return NULL;
     else
         nIndex = -1;

     if ( nIndex )
     if ( ( nIndex = AccessResource( hResFile, hResIndex ) ) != -1 &&
         _lread( nIndex, lpIcon, wSize ) != -1 )
         _lclose( nIndex );
     else
         {
         if ( nIndex != -1 )
         _lclose( nIndex );
         GlobalUnlock( hRes );
         return NULL;
         }

     /* Remove magic word. */
     wSize -= 2;
     while ( wSize-- )
        {
        *lpIcon = *( lpIcon+2 );
        lpIcon++;
        }

     GlobalUnlock( hRes );
     GlobalReAlloc( hRes, ( DWORD )wSize, 0 );

     return ( hRes );
 }

 void IconTestCommand ( hWnd, wCommand )
 HWND hWnd;
 WORD wCommand;
 {
     FARPROC lpResourceHandler;
     FARPROC lpOld;
     HDC     hDC;
     HICON   hIcon;
     HANDLE  hAppDLL;
     HANDLE  hModule;
     int     nDrawn;


     switch ( wCommand )
        {
        case CMD_GETICON:
           DummyEntry (  );
           hDC = GetDC ( hWnd );
           TextOut ( hDC, 10, 10, ( LPSTR ) "LibIcon", 7 );

           hAppDLL = LoadLibrary ( (LPSTR)"ICONLIB.LIB" );

           if ( hAppDLL < 32 )
              MessageBox ( hWnd, (LPSTR)"Loading DLL failed!",
                 (LPSTR)szFuncName, MB_OK );
           else
              {
              hModule = GetModuleHandle ( ( LPSTR )"ICONLIB" );
              if ( hModule != NULL )
                 {
                 lpResourceHandler = MakeProcInstance (
                    (FARPROC)ResourceHandler, hInst );
                                                     /* Install own handler. *
                 lpOld = SetResourceHandler( hModule, RT_ICON,
                    lpResourceHandler );

                 hIcon = LoadIcon ( hModule, ( LPSTR ) "LibIcon" );
                 nDrawn = DrawIcon ( hDC, 10, 25, hIcon );

                 FreeProcInstance( SetResourceHandler( hModule, RT_ICON,
                    ( FARPROC )lpOld ) );
                 }
              else
                 MessageBox ( hWnd, (LPSTR)"Resource Handlers not initialized"
                    (LPSTR)szFuncName, MB_OK );

              FreeLibrary ( hAppDLL );
              }
           ReleaseDC ( hWnd, hDC );
           break;

        default:
           return;
        }
 }



 INFLATE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\INFLATE.C

 /*
  *   InflateRect
  *
  *   This program demonstrates the use of the InflateRect function. The
  *   InflateRect function increase or decreases the values in the given
  *   LPRECT structure according to the x and y parameters in the function
  *   call. To demonstrate the increase in size of the rectangle described
  *   by lpRect in this application, after InflateRect was called, the
  *   rectangle was inverted using InvertRect.
  */

 #include "windows.h"

 long  FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon          = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   LocalFree( (HANDLE)pHelloClass );
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   HDC hDC;        /** handle to display context    **/
   RECT lpRect;    /** rectangle coordinates structure  **/

   HelloInit( hInstance );
   hWnd = CreateWindow((LPSTR)"Sample", (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /** get handle to display context **/
   hDC = GetDC(hWnd);

 /** fill lpRect with coordinate info for rectangle **/
   lpRect.left = 50;
   lpRect.top  = 50;
   lpRect.right = 150;
   lpRect.bottom = 150;

   MessageBox(GetFocus(), (LPSTR)"a small rectangle",
       (LPSTR)"I am about to InvertRect...", MB_OK);

 /** invert pixels in lpRect **/
   InvertRect (hDC, (LPRECT) & lpRect);

   MessageBox(GetFocus(), (LPSTR)"the rectangle",
       (LPSTR)"I am about to InflateRect...", MB_OK);

 /** inflate rect by 10 in x direction and 10 in y direction **/
   InflateRect((LPRECT) & lpRect, 10, 10);

   MessageBox(GetFocus(), (LPSTR)"the inflated rectangle",
       (LPSTR)"I am about to InvertRect...", MB_OK);

 /** invert the inflated rect to show it is now bigger **/
   InvertRect (hDC, (LPRECT) & lpRect);

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 INTERSEC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\INTERSEC.C

 /*
  *   IntersectRect
  *
  *   This example application demonstrates the use of the IntersectRect
  *   function. The IntersectRect function finds the largest area common
  *   to two RECT structures and puts the representation of the intersection
  *   in the RECT structure defined by the first parameter in the call to
  *   IntersectRect. IntersectRect is called twice in this application. The
  *   first time it is called, there is no area common to the two rectangles,
  *   the second time it is called, there is a common area.
  */

 #include "windows.h"

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon          = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HDC hDC;       /** handle to display context   **/
     RECT lpRect1;     /** rectangle coordinates structure   **/
     RECT lpRect2;     /** rectangle coordinates structure   **/
     RECT lpRect3;     /** rectangle coordinates structure   **/
     RECT destRect;     /** target rectangle coord structure  **/

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
                         (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,     /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

 /** get handle to display context **/
    hDC = GetDC(hWnd);

 /** fill lpRect1 with coordinate info for rectangle **/
    lpRect1.left = 10;
    lpRect1.top  = 10;
    lpRect1.right= 150;
    lpRect1.bottom=150;

 /** fill lpRect2 with coordinate info for rectangle **/
    lpRect2.left = 160;
    lpRect2.top  = 10;
    lpRect2.right= 210;
    lpRect2.bottom=50;

 /** fill lpRect3 with coordinate info for rectangle **/
    lpRect3.left = 30;
    lpRect3.top  = 30;
    lpRect3.right= 200;
    lpRect3.bottom=200;

    MessageBox(hWnd,(LPSTR)"three rectangles",
         (LPSTR)"I am about to InvertRect...",MB_OK);

 /** invert pixels in lpRect1 **/
    InvertRect (hDC,(LPRECT)&lpRect1);

 /** invert pixels in lpRect2 **/
    InvertRect (hDC,(LPRECT)&lpRect2);

 /** invert pixels in lpRect3 **/
    InvertRect (hDC,(LPRECT)&lpRect3);

    TextOut(hDC,60,0,(LPSTR)"RECT 1",(int)6);
    TextOut(hDC,160,0,(LPSTR)"RECT 2",(int)6);
    TextOut(hDC,90,210,(LPSTR)"RECT 3",(int)6);

    MessageBox(hWnd,(LPSTR)"the intersection of rects 1 and 2",
         (LPSTR)"I am about to InvertRect...",MB_OK);

 /** find intersection of lpRect1 and lpRect2 and place in destRect  **/
    IntersectRect((LPRECT)&destRect,(LPRECT)&lpRect1,(LPRECT)&lpRect2);

 /** invert the intersection of lpRect1 and lpRect2 (should be empty) **/
    InvertRect (hDC,(LPRECT)&destRect);

    MessageBox(hWnd,(LPSTR)"the intersection of rects 1 and 3",
         (LPSTR)"I am about to InvertRect...",MB_OK);

 /** find intersection of lpRect1 and lpRect3 and place in destRect  **/
    IntersectRect((LPRECT)&destRect,(LPRECT)&lpRect1,(LPRECT)&lpRect3);

 /** invert the intersection of lpRect1 and lpRect2        **/
    InvertRect (hDC,(LPRECT)&destRect);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 INVAL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\INVAL.C

 /*
  *   InvalidateRect
  *
  *   This program demonstrates the use of the InvalidateRect function. The
  *   InvalidateRect function adds the given rectangle to the update region,
  *   which marks that rectangle for painting. InvalidateRect is called
  *   twice in this program: once with a specified rectangle identified by
  *   the lpRect parameter, and once with NULL sent as the parameter
  *   representing the rectangle to invalidate, which causes the whole
  *   client area to be invalidated. Both times the "bErase" paramter is
  *   TRUE which causes the given rectangles to be erased. Also, both times
  *   InvalidateRect is called, UpdateWindow is called immediately after to
  *   ensure that the rectangle is immediately redrawn.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   DWORD rectcolor = RGB (0x22, 0x22, 0x22); /* color for the brush   */
   HDC hDC;     /* handle to display context        */
   HBRUSH hMyBrush;   /* handle to brush          */
   RECT lpRect;       /* structure to hold rectangle coordinates */

   if (!hPrevInstance)
     {
     WNDCLASS   HelloClass;

     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Sample Application";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"Sample Applicati
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

 /* create brush to fill rectangle with */
   hMyBrush = CreateSolidBrush (rectcolor);

 /* get handle to display context */
   hDC = GetDC (hWnd);

 /* select brush into display context */
   SelectObject (hDC, hMyBrush);

 /* draw a rectangle so we can see InvalidateRect's effects */
   Rectangle (hDC, 5, 5, 650, 250);

 /* fill lpRect with coordinate information */
   lpRect.left = 10;
   lpRect.top  = 10;
   lpRect.right = 50;
   lpRect.bottom = 50;

 /* notify user call to InvalidateRect about to occur */
   MessageBox (GetFocus (), (LPSTR)"a small rectangle",
       (LPSTR)"I am about to InvalidateRect...", MB_OK);

 /* invalidate the rect.identified by lpRect (TRUE param. causes erase) */
   InvalidateRect (hWnd, (LPRECT) & lpRect, (BOOL)TRUE);

 /* call UpdateWindow so that draw will take place immediately */
   UpdateWindow (hWnd);

 /* notify user call to InvalidateRect about to occur */
   MessageBox (GetFocus (), (LPSTR)"the whole client area",
       (LPSTR)"I am about to InvalidateRect...", MB_OK);

 /* invalidate the client area (TRUE param. causes erase) */
   InvalidateRect (hWnd, (LPRECT)NULL, (BOOL)TRUE);

 /* call UpdateWindow so that draw will take place immediately */
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 INVALRGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\INVALRGN.C

 /*
  *   InvalidateRgn
  *
  *   This program demonstrates the use of the InvalidateRgn function.
  *   InvalidateRgn marks the given region for painting during the next
  *   "paint session." The next paint session starts after the next WM_PAINT
  *   message is received by the window. InvalidateRgn is called from WinMain
  *   in this sample application. UpdateWindow is called directly after
  *   InvalidateRgn to send a WM_PAINT message.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   HRGN hRegion;
   HDC  hDC;
   RECT ClearRect;

   if (!hPrevInstance)
     {
     WNDCLASS   HelloClass;

     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Sample Application";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"Sample Applicati
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   hDC = GetDC (hWnd);
   hRegion = CreateEllipticRgn (5, 5, 220, 110);

   GetClientRect (hWnd, (LPRECT) & ClearRect);
   InvertRect (hDC, (LPRECT) & ClearRect);

   MessageBox (GetFocus (), (LPSTR)"Call InvalidateRgn",
       (LPSTR)"I am about to...", MB_OK);

   InvalidateRgn (hWnd, hRegion, TRUE);   /*  mark the region for painting
 /*  TRUE parameter says erase first */
   UpdateWindow (hWnd);  /* force a paint */

   ReleaseDC (hWnd, hDC);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 INVERT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\INVERT.C

 /*
  *   InvertRect
  *
  *   This program demonstrates the use of the InvertRect function. The
  *   InvertRect function inverts the contents of the given rectangle.
  *   In this application, two calls are made to InvertRect. The first
  *   inverts the pixels in a rectangle specified by lpRect. The second
  *   call inverts the whole client area.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   HelloClass;

     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Sample Application";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hMenu = CreateMenu ();
   ChangeMenu (hMenu, NULL, "Invert!", 100, MF_APPEND);

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"InvertRect",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, hMenu, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   HDC hDC;
   RECT rRect;

   switch (message)
     {
     case WM_COMMAND:
       if (wParam == 100)
         {
         hDC = GetDC (hWnd);

         rRect.left = 10; /* fill lpRect with coordinate info for rectangle */
         rRect.top  = 10;
         rRect.right = 150;
         rRect.bottom = 20;

         InvertRect (hDC, (LPRECT) &rRect);    /** invert pixels in lpRect **/
         ReleaseDC (hWnd, hDC);
         }
       else
         return DefWindowProc (hWnd, message, wParam, lParam);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 INVERTRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\INVERTRG.C

 /*
  *   InvertRgn
  *
  *   This program demonstrates the use of the InvertRgn function. InvertRgn
  *   inverts the pixels in the given region. InvertRgn is called from
  *   WinMain in this sample application.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   HRGN hRegion;
   HDC  hDC;

   if (!hPrevInstance)
     {
     WNDCLASS   HelloClass;

     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Sample Application";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"InvertRgn Applic
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   hDC = GetDC (hWnd);
   hRegion = CreateEllipticRgn (5, 5, 220, 100);

 /*******    invert the region "hRegion"    *******/
   if (!InvertRgn (hDC, hRegion))
     MessageBox (GetFocus (), (LPSTR)"InvertRgn failed",
         (LPSTR)" ", MB_OK);
   ReleaseDC (hWnd, hDC);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 ISCHILD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CHILD\ISCHILD.C

 /*
  *
  *   IsChild
  *
  *   This program demonstrates the use of the IsChild function. IsChild
  *   determines if one window is a child of another. IsChild is called from
  *   WinMain in this sample application.
  */

 #include "windows.h"

 long  FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);
 /* parent's window procedure */

 long  FAR PASCAL ChildAProc(HWND, unsigned, WORD, LONG);
 /* child A's window procedure */

 long  FAR PASCAL ChildBProc(HWND, unsigned, WORD, LONG);
 /* child B's window procedure */

 HWND hChAWnd = NULL;  /* handle to Child A's window */
 HWND hChBWnd = NULL;  /* handle to Child B's window */

 /* Procedure called when the application is loaded for the first time */

 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon     = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName   = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc   = HelloWndProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon     = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName   = (LPSTR)"CHILD A";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc   = ChildAProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon     = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName   = (LPSTR)"CHILD B";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc   = ChildBProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   LocalFree( (HANDLE)pHelloClass );
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   BOOL  bChild;   /* return value from IsChild */

   HelloInit( hInstance );

   hWnd = CreateWindow((LPSTR)"Sample Application", (LPSTR)"IsChild (PARENT)",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

   hChAWnd = CreateWindow((LPSTR)"CHILD A", (LPSTR)"Child A",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION | WS_CLIPSIBLINGS,
       5, 5,
       150, 150,
       hWnd, 1,   hInstance, NULL);

   hChBWnd = CreateWindow((LPSTR)"CHILD B",   (LPSTR)"Child B",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION | WS_CLIPSIBLINGS,
       270, 5,
       150, 150,
       hWnd,   2,   hInstance, NULL);

 /***************************************************************************/

   MessageBox(GetFocus(), (LPSTR)"Child A is a Child of the Parent Window",
       (LPSTR)"Checking to see if...",
       MB_OK);

   bChild = IsChild(hWnd, hChAWnd);

   if (bChild)
     MessageBox(GetFocus(), (LPSTR)"IS a child of the Parent Window",
         (LPSTR)"'IsChild' says that Child A...",
         MB_OK);
   else
     MessageBox(GetFocus(), (LPSTR)"is NOT a child of the Parent Window",
         (LPSTR)"'IsChild' says that Child A...",
         MB_OK);


   MessageBox(GetFocus(), (LPSTR)"Child A is a child of Child B",
       (LPSTR)"Checking to see if...",
       MB_OK);

   bChild = IsChild(hChBWnd, hChAWnd); /* is Child A a child of Child B? */

   if (bChild)
     MessageBox(GetFocus(), (LPSTR)"IS a child of Child B",
         (LPSTR)"'IsChild' says that Child A...",
         MB_OK);
   else
     MessageBox(GetFocus(), (LPSTR)"is NOT a child of Child B",
         (LPSTR)"'IsChild' says that Child A...",
         MB_OK);

 /***************************************************************************/

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_LBUTTONDOWN:
     MessageBox(GetFocus(), (LPSTR)"Left Button Click", (LPSTR)"PARENT WINDOW"
         MB_OK);
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }


 long  FAR PASCAL ChildAProc( hChAWnd, message, wParam, lParam )
 HWND hChAWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_LBUTTONDOWN:
     MessageBox(hChAWnd, (LPSTR)"Left Button Click",
         (LPSTR)"CHILD A",
         MB_OK);
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hChAWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }


 long  FAR PASCAL ChildBProc( hChBWnd, message, wParam, lParam )
 HWND hChBWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_LBUTTONDOWN:
     MessageBox(hChBWnd, (LPSTR)"Left Button Click",
         (LPSTR)"CHILD B",
         MB_OK);
     break;

   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hChBWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 ISDLGMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\ISDLGMSG.C

 /*
  *   IsDialogMessage
  *
  *   This program demonstrates the use of the IsDialogMessage function.
  *   The IsDialogMessage function is usually used in a window's message
  *   loop to determine if messages are intended for modeless dialog boxes.
  *   If a message it intended for the given dialog box, IsDialogMessage
  *   processes the mesage for the dialog box. IsDialogMessage is called
  *   from WinMain in this sample application
  */

 #include "windows.h"
 #include "isdlgmsg.h"

 HANDLE hInst;
 HWND hToTheDialog = NULL;     /*** handle to the modeless dialog box ***/

 FARPROC lpprocDialog;
 long  FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);


 BOOL FAR PASCAL DialogBoxProc (hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_INITDIALOG:
     return TRUE;
     break;

   case WM_COMMAND:
     switch (wParam)
     {
     case TOP_CONTROL:
       MessageBox (NULL, (LPSTR)"The message was processed",
           (LPSTR)" ", MB_OK);
       break;

     case ID_OK:
       EndDialog (hDlg, TRUE);
       break;
     }
     break;

   case WM_DESTROY:
     hToTheDialog = NULL;
     return TRUE;
     break;

   default:
     return FALSE;
     break;
   }
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit (hInstance)
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon          = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   HelloInit (hInstance);
   hMenu = LoadMenu (hInstance, "isdlgmsg");

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"IsDialogMessage"
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, hMenu, hInstance, NULL);
   hInst = hInstance;

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
   {
     if (hToTheDialog == NULL || !IsDialogMessage (hToTheDialog, &msg))
     {/*  Make sure the message is meant for this window...  */

       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
     }
   }
   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_COMMAND:
     if (wParam == 80)
     {
       lpprocDialog = MakeProcInstance ( (FARPROC)DialogBoxProc, hInst);
       hToTheDialog = CreateDialog (hInst, MAKEINTRESOURCE (2), hWnd,
           lpprocDialog);
     }
     break;

   case WM_DESTROY:
     FreeProcInstance ( (FARPROC)lpprocDialog);
     PostQuitMessage (0);
     break;

   default:
     return DefWindowProc (hWnd, message, wParam, lParam);
     break;
   }
   return (0L);
 }




 ISICONIC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ICON\ISICONIC.C

 /*
  *   IsIconic
  *
  *   This program demonstrates the use of the IsIconic function. The
  *   IsIconic function returns a boolean telling whether the  specified
  *   window is iconic. Choosing the "Iconic?" option in the system menu
  *   enacts the call to IsIconic in this sample application.
  */

 #include "windows.h"
 #define IDSABOUT 200

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName     = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"Sample Applicati
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL,     NULL, hInstance, NULL);

 /* Insert "Iconic?" into system menu */
   hMenu = GetSystemMenu (hWnd, FALSE);
   ChangeMenu (hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
   ChangeMenu (hMenu, 0, (LPSTR)"Iconic?", IDSABOUT, MF_APPEND | MF_STRING);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   BOOL icon;   /** holds return value from call to IsIconic **/

   switch (message)
     {
     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDSABOUT:
           icon = IsIconic (hWnd);    /**  is window iconic ?     **/
           if (icon)       /**  if yes, say so         **/
             MessageBox (hWnd, (LPSTR)"This window is iconic",
                 (LPSTR)"ICONIC INFO", MB_OK);
           else /**  if window not iconic, say so  **/
             MessageBox (hWnd, (LPSTR)"This window is NOT iconic",
                 (LPSTR)"ICONIC INFO", MB_OK);
           break;
         default:
           return DefWindowProc (hWnd, message, wParam, lParam);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 ISRECEMP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\ISRECEMP.C

 /*
  *   IsRectEmpty
  *
  *   This example application demonstrates the use of the IsRectEmpty
  *   function. IsRectEmpty returns a boolean specifying whether or not
  *   the given rectangle is empty. A rectangle is empty if either the
  *   height or width is 0. IsRectEmpty is called twice in WinMain in this
  *   sample application. In the first call, IsRectEmpty is passed a non-
  *   empty rectangle. In the second call, it is passed an empty rectangle.
  */

 #include "windows.h"

 long  FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon          = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   LocalFree( (HANDLE)pHelloClass );
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   HDC hDC;       /** handle to display context     **/
   RECT lpRect1;     /** rectangle coordinates structure     **/
   RECT lpRect2;     /** rectangle coordinates structure     **/
   BOOL EMPTY;      /** return value from IsRectEmpty calls **/

   HelloInit( hInstance );
   hWnd = CreateWindow((LPSTR)"Sample Application", (LPSTR)"Sample Application
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL,   NULL, hInstance, NULL);

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );

 /** get handle to display context **/
   hDC = GetDC(hWnd);

 /** fill lpRect1 with coordinate info for non-empty rectangle **/
   lpRect1.left = 10;
   lpRect1.top   = 10;
   lpRect1.right = 150;
   lpRect1.bottom = 150;

 /** fill lpRect2 with coordinate info for  empty rectangle **/
   lpRect2.left = 260;
   lpRect2.top   = 10;
   lpRect2.right = 260;
   lpRect2.bottom = 200;

   MessageBox(GetFocus(), (LPSTR)"the non-empty rectangle",
       (LPSTR)"I am about to InvertRect...", MB_OK);

 /** invert pixels in lpRect1  (the non-empty rectangle) **/
   InvertRect (hDC, (LPRECT) & lpRect1);

   MessageBox(GetFocus(), (LPSTR)"with this non-empty rectangle",
       (LPSTR)"I am about to call IsRectEmpty...", MB_OK);

 /** see is lpRect1 is empty **/
   EMPTY = IsRectEmpty((LPRECT) & lpRect1);
   if (EMPTY)
     MessageBox(GetFocus(), (LPSTR)"meaning the rectangle IS empty",
         (LPSTR)"IsRectEmpty returned TRUE...", MB_OK);
   else
     MessageBox(GetFocus(), (LPSTR)"meaning the rectangle is NOT empty",
         (LPSTR)"IsRectEmpty returned FALSE...", MB_OK);

   InvalidateRect(hWnd, NULL, TRUE);

   MessageBox(GetFocus(), (LPSTR)"the EMPTY rectangle",
       (LPSTR)"I am about to InvertRect...", MB_OK);

 /** invert pixels in lpRect2 (the empty rectangle) **/
   InvertRect (hDC, (LPRECT) & lpRect2);

   MessageBox(GetFocus(), (LPSTR)"with this empty rectangle",
       (LPSTR)"I am about to call IsRectEmpty...", MB_OK);

 /** see is lpRect2 is empty **/
   EMPTY = IsRectEmpty((LPRECT) & lpRect2);
   if (EMPTY)
     MessageBox(GetFocus(), (LPSTR)"meaning the rectangle IS empty",
         (LPSTR)"IsRectEmpty returned TRUE...", MB_OK);
   else
     MessageBox(GetFocus(), (LPSTR)"meaning the rectangle is NOT empty",
         (LPSTR)"IsRectEmpty returned FALSE...", MB_OK);

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 ISWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ISWIN.C

 /*
  *   IsWindow
  *
  *   This program demonstrates the use of the IsWindow function. The IsWindow
  *   function checks to see if the given handle is indeed a handle to a valid
  *   window.
  */

 #include "windows.h"

 long  FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

   pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pHelloClass->hIcon     = LoadIcon( hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName   = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return FALSE;

   LocalFree( (HANDLE)pHelloClass );
   return TRUE;        /* Initialization succeeded */
 }


 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   MSG   msg;
   HWND  hWnd;       /** VALID HANDLE TO VALID WINDOW  **/
   HWND invalWnd;     /** INVALID HANDLE TO PHONY WINDOW **/
   HMENU hMenu;
   BOOL isvalid;     /** BOOLEAN TO HOLD RETURN VALUE FROM IsWindow **/

 /** INVALID ASSIGNMENT TO A HANDLE TO A WINDOW **/
   invalWnd = 44;

   HelloInit( hInstance );

 /** VALID ASSIGNMENT TO A HANDLE TO A WINDOW   **/
   hWnd = CreateWindow((LPSTR)"Sample Application", (LPSTR)"Sample Application
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL,   NULL, hInstance, NULL);

 /* Make window visible according to the way the app is activated */
   ShowWindow( hWnd, cmdShow );
   UpdateWindow( hWnd );
   MessageBox(GetFocus(), (LPSTR)"Checking if this window valid", (LPSTR)" ",
       MB_OK);

 /** is hWnd a valid handle to a window? **/
   isvalid = IsWindow(hWnd);

 /** if yes  **/
   if (isvalid)
 /** say so **/
     MessageBox(GetFocus(), (LPSTR)"this window is valid", (LPSTR)"WINDOW INFO
         MB_OK);
   else /** if not valid, say so **/
     MessageBox(GetFocus(), (LPSTR)"this window is NOT valid", (LPSTR)"WINDOW
         MB_OK);

   MessageBox(GetFocus(), (LPSTR)"Checking if phoney window valid", (LPSTR)" "
       MB_OK);

 /** is invalWnd a valid handle to a window? **/
   isvalid = IsWindow(invalWnd);
 /** if yes, say so **/
   if (isvalid)
     MessageBox(GetFocus(), (LPSTR)"the phony window is valid", (LPSTR)"WINDOW
         MB_OK);
   else /** if not valid, say so **/
     MessageBox(GetFocus(), (LPSTR)"the phony window is NOT valid", (LPSTR)"WI
         MB_OK);

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long  FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_DESTROY:
     PostQuitMessage( 0 );
     break;

   default:
     return DefWindowProc( hWnd, message, wParam, lParam );
     break;
   }
   return(0L);
 }




 ISZOOMED.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\ISZOOMED.C

 /*
  *   IsZoomed
  *
  *   This program demonstrates the use of the IsZoomed function. The IsZoomed
  *   function returns a boolean telling whether or not the given window is
  *   zoomed (maximized). Choosing the "Zoomed?" option in the system menu
  *   enacts the call to IsZoomed in this sample application.
  */

 #include "windows.h"
 #define IDSABOUT 200

 char  szAbout[10];

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LPTR, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon             = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName     = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);

   hWnd = CreateWindow ( (LPSTR)"Sample Application", (LPSTR)"Sample Applicati
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, NULL, hInstance, NULL);

 /* Insert "Zoomed?" into system menu */
   hMenu = GetSystemMenu (hWnd, FALSE);
   ChangeMenu (hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
   ChangeMenu (hMenu, 0, (LPSTR)"Zoomed?", IDSABOUT, MF_APPEND | MF_STRING);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   PAINTSTRUCT ps;
   BOOL Zoomed;

   switch (message)
     {
     case WM_SYSCOMMAND:
       switch (wParam)
         {
         case IDSABOUT:
 /***********************************************************************/
           Zoomed = IsZoomed (hWnd);
           if (Zoomed)
             MessageBox (hWnd, (LPSTR)"This window is zoomed",
                        (LPSTR)"ZOOM INFO", MB_OK);
           else
             MessageBox (hWnd, (LPSTR)"This window is NOT zoomed",
                        (LPSTR)"ZOOM INFO", MB_OK);
 /************************************************************************/
         break;

         default:
           return DefWindowProc (hWnd, message, wParam, lParam);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 JOURNAL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\JOURNAL\JOURNAL.C

 /*  Journal - Dynamic Link Library Demonstrating Windows 2.0 Journal Hooks.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       DLL entry points and hook function call-backs.
 *
 *   Functions:
 *       StartRecord() - Entry point for initiating message recording to file.
 *       StopRecord()  - Entry point for halting recording.
 *       StartPlay()   - Entry point for initiating message playback from file
 *       StopPlay()    - Entry point to halt message playback.
 *       Record()      - Call-back for WH_JOURNALRECORD hook function.
 *       Play()        - Call-back for WH_JOURNALPLAYBACK hook function.
 *       LIBINIT.ASM   - MASM initialization code.  Used to get library
 *                       instance handle.
 *
 *   Description:
 *       Windows 2.0 introduces new hook functions, WH_JOURNALRECORD and
 *       WH_JOURNALPLAYBACK, which hook into the system message queue
 *       allowing keyboard and mouse messages to be recorded for later
 *       playback.  A natural use of these functions is for creating
 *       demos and test suites, though other imaginative uses must also
 *       exist.  This DLL could be easily referenced by any application
 *       to quickly add a demo mode.  Note: Use extreme care when developing
 *       a demo file.  Window position may change, overlapped window
 *       ordering may be different, and display device may vary.  This
 *       will impact on demos using the mouse to open windows, move
 *       windows, manipulate dialog boxes, etc.  Note:  Journal hooks
 *       are disabled by system modal dialog/message boxes.  This is a
 *       design feature that must be taken into consideration.
 *
 *   Limits:
 *       Very little error checking is used.  This should be added to any
 *       "real" app.  I have indicated areas that require error checking.
 *       The hook functions read and write directly to disk via low-level
 *       functions, read() and write().  This impacts on performance.
 *       Using a 512 or 1024 byte buffer is recommended.  Remember, do
 *       not use C run-time buffered stream I/O functions.
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */

 #include "windows.h"
 #include "memory.h"
 #include "dos.h"

 /* File used to record/play messages */
 #define FILENAME "DIARY.BIN"

 /* System queue message structure */
 typedef struct sysmsg {
     unsigned message;
     WORD wParam1;
     WORD wParam2;
     DWORD lParam;
 } SYSMSG;
 typedef SYSMSG FAR *LPSYSMSG;

 /* Static definitions for hooks and chains */
 FARPROC lpprocRecord;
 FARPROC lplpfnNextRecord;
 FARPROC lpprocPlay;
 FARPROC lplpfnNextPlay;

 /* Global variables (Defined in DLL's DGROUP) */
 HANDLE          hFile;
 OFSTRUCT        of;
 SYSMSG          bufMsg;
 char far        *lpTmp;
 int             nNumMsg, nMsgCtr;
 BOOL            bRecord, bPlay;
 DWORD           dwBaseTime;

 /* Handle to the DLL instance from Libinit.asm */
 extern HANDLE   LIBINST;

 /* Function proto-types */
 DWORD   FAR PASCAL Record( int, WORD, LPSYSMSG );
 DWORD   FAR PASCAL Play( int, WORD, LPSYSMSG );
 void    FAR PASCAL StartRecord();
 void    FAR PASCAL StopRecord();
 void    FAR PASCAL StartPlay();
 void    FAR PASCAL StopPlay();

 /* Undocumented Kernel Function proto-types.  See C run-time doc for
    description of related functions and their parameters. */
 int     FAR PASCAL _lclose( int );
 int     FAR PASCAL _llseek( int, long, int );
 int     FAR PASCAL _lread( int, LPSTR, int );
 int     FAR PASCAL _lwrite( int, LPSTR, int );

 /*  StartRecord() - Set WH_JOURNALRECORD Hook.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       Initialize for and set WN_JOURNALRECORD Hook.
 *
 *   Arguments:
 *       none
 *
 *   Return Value:
 *       void
 *
 *   Globals (modified):
 *       hFile            - Handle to write-only file.
 *       bRecord          - Boolean indicating state of Record hook.
 *       dwBaseTime       - Reference system time when recording started.
 *       lpprocRecord     - Procedure-instance address of call-back fcn.
 *       lplpfnNextRecord - Procudure-instance address of any previous
 *                          Record hook.  Note: Chaining may not be
 *                          applicable.
 *
 *   Globals (referenced):
 *       LIBINST       - Handle to instance for LIBINIT.ASM init. code.
 *
 *   Description:
 *       Isolates the application from the actual hooking and unhooking
 *       details.  Allows the application to call high-level routines
 *       which take care of the dirty work.
 *
 *   Limits:
 *       Insufficient error checking.  See code for comments.
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 void FAR PASCAL StartRecord()
 {
     /* Do not allow recording while playing! DONE! */
     if (bPlay) {
        MessageBox( GetFocus(), (LPSTR)"Currently Playing!", (LPSTR)NULL, MB_O
        return;
     }

     /* Create write-only file, initialize OFSTRUCT, close. Add error checking
     hFile = OpenFile( (LPSTR)FILENAME, &of, OF_CREATE | OF_WRITE | OF_EXIST )

     /* Initialize: Record on, and Base Time. */
     bRecord = TRUE;
     dwBaseTime = GetTickCount();

     /* Set the Journal Record hook.  Add error checking! */
     lpprocRecord = MakeProcInstance( (FARPROC)Record, LIBINST);
     lplpfnNextRecord = SetWindowsHook( WH_JOURNALRECORD, lpprocRecord );

     return;
 }
 /*
 */

 /*  StopRecord() - Unhook WH_JOURNALRECORD Hook.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       Stop further recording by unhooking recording call-back fcn.
 *
 *   Arguments:
 *       none
 *
 *   Return Value:
 *       void
 *
 *   Globals (modified):
 *       bRecord          - Boolean indicating state of Record hook.
 *
 *   Globals (referenced):
 *       lpprocRecord     - Procedure-instance address of call-back fcn.
 *
 *   Description:
 *       Isolates the application from the actual hooking and unhooking
 *       details.  Allows the application to call high-level routines
 *       which take care of the dirty work.
 *
 *   Limits:
 *       What to do if UnhookWindowsHook fails?  Add error checking!
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 void FAR PASCAL StopRecord()
 {
     /* Only unhook if currently hooked. */
     if (bRecord)
        UnhookWindowsHook( WH_JOURNALRECORD, lpprocRecord );
     /* Let the world know that hook is off */
     bRecord = FALSE;
     return;
 }
 /*
 */

 /*  StartPlay() - Set WH_JOURNALPLAYBACK Hook.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       Initialize for and set WN_JOURNALPLAYBACK Hook.
 *
 *   Arguments:
 *       none
 *
 *   Return Value:
 *       void
 *
 *   Globals (modified):
 *       hFile          - Handle to read-only file.
 *       nNumMsg        - Number of messages recorded (in file).
 *       nMsgCtr        - Initialize message counter to zero.
 *       bPlay          - Boolean indicating state of Play hook.
 *       dwBaseTime     - Reference system time when playing started.
 *       lpprocPlay     - Procedure-instance address of call-back fcn.
 *       lplpfnNextPlay - Procudure-instance address of any previous
 *                        Play hook.  Note: Chaining may not be
 *                        applicable.
 *
 *   Globals (referenced):
 *       bRecord       - Boolean indicating state of Record hook (modified
 *                       if StopRecord() called).  See code.
 *       LIBINST       - Handle to instance for LIBINIT.ASM init. code.
 *
 *   Description:
 *       Isolates the application from the actual hooking and unhooking
 *       details.  Allows the application to call high-level routines
 *       which take care of the dirty work.
 *
 *   Limits:
 *       Insufficient error checking.  See code for comments.
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 void FAR PASCAL StartPlay()
 {
     /* Open file so the OFSTRUCT is initialized.  Add error checking! */
     hFile = OpenFile( (LPSTR)FILENAME, &of, OF_READ );
     /* Read the first message into buffer.  Required if HC_GETNEXT is
        first call to Playback hook function.  Must have message ready! */
     _llseek( hFile, 0L, 0 );
     _lread( hFile, (LPSTR)&bufMsg, sizeof(SYSMSG) );
     /* How many messages are stored? */
     nNumMsg = _llseek( hFile, 0L, 2 ) / sizeof(SYSMSG);
     /* Don't leave files open long */
     _lclose( hFile );

     /* If no messages were recorded, none to play back. DONE! */
     if (!nNumMsg) {
        MessageBox( GetFocus(), (LPSTR)"Nothing Recorded!", (LPSTR)NULL, MB_OK
        return;
     }

     /* Trick: Allows infinite loop to be set!  One can record the steps
        required to start playing.  This code turns off further recording. */
     if (bRecord)
        StopRecord();

     /* Initialize: First Message, Play on, and Base Time. */
     nMsgCtr = 0;
     bPlay = TRUE;
     dwBaseTime = GetTickCount();

     /* Set the Journal Playback hook.  Add error checking! */
     lpprocPlay = MakeProcInstance( (FARPROC)Play, LIBINST);
     lplpfnNextPlay = SetWindowsHook( WH_JOURNALPLAYBACK, lpprocPlay );

     return;
 }
 /*
 */

 /*  StopPlay() - Unhook WH_JOURNALPLAYBACK Hook.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       Stop further calls to playback function, Play(), by unhooking.
 *
 *   Arguments:
 *       none
 *
 *   Return Value:
 *       void
 *
 *   Globals (modified):
 *       bPlay          - Boolean indicating state of Play hook.
 *
 *   Globals (referenced):
 *       lpprocPlay     - Procedure-instance address of call-back fcn.
 *
 *   Description:
 *       Isolates the application from the actual hooking and unhooking
 *       details.  Allows the application to call high-level routines
 *       which take care of the dirty work.
 *
 *   Limits:
 *       What to do if UnhookWindowsHook fails?  Add error checking!
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 void FAR PASCAL StopPlay()
 {
     /* Only unhook if currently hooked */
     if (bPlay)
        UnhookWindowsHook( WH_JOURNALPLAYBACK, lpprocPlay );
     /* Let the world know that hook is off */
     bPlay = FALSE;
     return;
 }
 /*
 */

 /*  Record() - Copy system event messages to a file for later playback.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       WH_JOURNALRECORD call-back hook function used to record messages.
 *
 *   Arguments:
 *       nCode  - Hook code
 *       wParam - Not used
 *       lParam - Long pointer to a system message, LPSYSMSG.
 *
 *   Return Value:
 *       DWORD value depends on Hook Code.
 *
 *   Globals (modified):
 *       lpTmp            - Far pointer used to get DS for movedata().
 *       bufMsg           - Temporary message storage.
 *       hFile            - Handle to write-only file.
 *
 *   Globals (referenced):
 *       dwBaseTime       - Reference system time when recording started.
 *                          Used to compute elapsed time for later playback.
 *                          Elapsed time is placed in bufMsg.lParam.
 *
 *   Description:
 *       From hook function memo (modified):
 *       "The hook code of interest is HC_ACTION.
 *       wParam is unused.
 *       lParam is a long pointer to a SYSMSG structure (LPSYSMSG)
 *           with the current message.
 *
 *       The SYSMSG structure is identical to that used by the
 *       WH_JOURNALPLAYBACK structure.  (see below).
 *
 *       I use this hook to record a sequence of user-initiated
 *       events which I later playback, but there are other
 *       uses I imagine.  Since the system time when one records
 *       and when one plays back the recording will, in general,
 *       be different, I keep a global variable (dwBaseTime) around
 *       containing the time at the start of the sequence, and store
 *       elapsed times in the lParam of the SYSMSG.  When I playback the
 *       sequence, I convert those elapsed times into current
 *       times by the inverse operation.
 *
 *       The return value from HC_ACTION is ignored.  Return 0L."
 *
 *   Limits:
 *       Insufficient file error checking.  See code for comments.
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 DWORD FAR PASCAL Record( nCode, wParam, lParam )
 int nCode;
 WORD wParam;
 LPSYSMSG lParam;
 {
     /* If it ain't HC_ACTION, pass it along */
     if (nCode != HC_ACTION )
        return DefHookProc( nCode, wParam, (LONG)lParam, (FARPROC FAR *)&lplpf

     /* Need a long pointer for FP_SEG */
     lpTmp = (char far *)&bufMsg;
     /* Get a local copy of the message */
     movedata( FP_SEG( lParam ), FP_OFF( lParam ),
               FP_SEG( lpTmp ), FP_OFF( lpTmp ),
               sizeof(SYSMSG) );
     /* Compute a delta time from beginning recording.  Message time is
        in milliseconds from system power-on.  WARNING: Wrap not handled.
        Wrapping only a problem if system on continuously for ~50 days. */
     bufMsg.lParam -= dwBaseTime;

     /* Reopen write-only file using OFSTRUCT.  Add error checking. */
     hFile = OpenFile( (LPSTR)FILENAME, &of, OF_REOPEN | OF_WRITE );
     /* Seek to the end of the file */
     _llseek( hFile, 0L, 2 );
     /* Write the message to disk */
     _lwrite( hFile, (LPSTR)&bufMsg, sizeof(SYSMSG) );
     /* Don't leave files open long */
     _lclose( hFile );

     return 0L;
 }
 /*
 */

 /*  Play() - Copy system event messages from file to system message queue.
 *
 *   Programmer:
 *       Eric Fogelin
 *       Microsoft Technical Support
 *
 *   Purpose:
 *       WH_JOURNALPLAYBACK call-back hook function used to replay messages.
 *
 *   Arguments:
 *       nCode  - Hook code
 *       wParam - Not used
 *       lParam - See Description section.
 *
 *   Return Value:
 *       DWORD value depends on Hook Code.
 *
 *   Globals (modified):
 *       lpTmp            - Far pointer used to get DS for movedata().
 *       bufMsg           - Temporary message storage.
 *       hFile            - Handle to read-only file.
 *       nMsgCtr          - Message counter specifies current message.
 *
 *   Globals (referenced):
 *       dwBaseTime       - Reference system time when playing started.
 *                          Used to compute playback time from elapsed time.
 *                          Elapsed time is in bufMsg.lParam.
 *       nNumMsg          - Number of total messages to playback.
 *
 *   Description:
 *       From hook function memo (modified):
 *       "There are two hook codes of interest:
 *
 *       HC_GETNEXT
 *       wParam is unused.
 *       lParam is a long pointer to a SYSMSG structure (LPSYSMSG)
 *           where the hook is to put the current messsage to playback.
 *
 *       HC_SKIP
 *       wParam is unused.
 *       lParam is unused.
 *
 *       The SYSMSG (System Queue Event) is like a MSG structure:
 *       typedef struct {
 *           unsigned message;
 *           WORD wParam1;
 *           WORD wParam2;
 *           DWORD lParam;
 *       } SYSMSG;
 *       The message is a regular Window message (WM_*), the wParam1
 *       is pretty much the same as the wParam for a  regular window
 *       message, (e.g. a VK_* for a message of WM_KEYDOWN), and the
 *       lParam is the current time (expressed as the number of
 *       timer ticks since system generation--see GetTickCount()).
 *
 *       The hook is used as follows.  Windows, after this hook
 *       is installed, disables hardware input.  It will call this
 *       hook in lieu of using the system queue until the hook is removed
 *       via UnhookWindowsHook.  Whenever the hook gets a HC_GETNEXT,
 *       it should poke a SYSMSG through the long pointer given in the
 *       lParam and return the time in timer ticks that needs to
 *       elapse before the event is ready to be played.  The lParam
 *       field of the SYSMSG should also contain the time (not delta
 *       time) to play the event.  If the time to play the event is
 *       now, or has passed, this hook should return 0L.  Whenever
 *       the hook gets a HC_SKIP, it should fetch the next event to
 *       poke through the lParam when it next gets a HC_GETNEXT,
 *       i.e. it should prepare, but not do it.
 *
 *       NOTES:
 *       - The hook may be called mutiple times with HC_GETNEXT
 *           before getting a HC_SKIP.  The hook should keep returning
 *           the same event through the lParam (with the same
 *           time-to-be-played in the lParam of the SYSMSG), and a
 *           decreasing elpased-time-until-event until it becomes
 *           0L, whereafter it returns 0L.
 *       - The first message the hook gets (of these two) can be either
 *           HC_SKIP or HC_GETNEXT.  Your initialization  code should
 *           be invariant.  (I do my initialization when I set the hook.)
 *       - If you want to turn the hook off from within the hook, call
 *           UnhookWindowsHook from the HC_SKIP case only.
 *       - If you want to play events as fast as possible, you'll find
 *           that simply returning 0L for every HC_GETNEXT and setting
 *           the play time to the current time won't work.  (You hang).
 *           I've had success using the mouse double-click speed +1 as
 *           the minimum time delay between events (except where the
 *           actual event times are less)."
 *
 *   Limits:
 *       Insufficient file error checking.  See code for comments.
 *
 *   History:
 *       2/15/87    - Initial version
 *       2/22/87    - Cleaned up
 *       2/22/87    - Documentation
 */
 DWORD FAR PASCAL Play( nCode, wParam, lParam )
 int nCode;
 WORD wParam;
 LPSYSMSG lParam;
 {
     long delta;

     switch ( nCode ) {
         case HC_SKIP:
             /* Bump up the message counter */
             nMsgCtr++;
             /* Have all messages been played?  Stop playing, if yes */
             if (nMsgCtr >= nNumMsg)
                StopPlay();

             /* Get message ready for next HC_GETNEXT */
             /* Reopen read-only file using OFSTRUCT.  Add error checking. */
             hFile = OpenFile( (LPSTR)FILENAME, &of, OF_REOPEN | OF_READ );
             /* Seek to the next message */
             _llseek( hFile, (long)nMsgCtr*sizeof(SYSMSG), 0 );
             /* Get a copy of the message in a local buffer */
             _lread( hFile, (LPSTR)&bufMsg, sizeof(SYSMSG) );
             /* Don't leave files open long */
             _lclose( hFile );

             return 0L;
             break;

         case HC_GETNEXT:
             /* Need a long pointer for FP_SEG */
             lpTmp = (char far *)&bufMsg;
             /* Put the local copy of the message into queue.  Note: Do
                not modify local message copy; may be asked repeatedly
                for message before next message is requested! */
             movedata( FP_SEG( lpTmp ), FP_OFF( lpTmp ),
                       FP_SEG( lParam ), FP_OFF( lParam ),
                       sizeof(SYSMSG) );

             /* Compute a delta time from beginning playback.  Message time is
                in milliseconds from system power-on.  WARNING: Wrap not
                handled.  Wrapping only a problem if system on continuously
                for ~50 days. */
             lParam->lParam = bufMsg.lParam + dwBaseTime;

             /* How long from current time must message be played? */
             delta = lParam->lParam - GetTickCount();

             /* Return time in milliseconds unless it has already passed
                (delta less than 0).  If passed, return 0. */
             if (delta > 0)
                 return delta;
             else
                 return 0L;
             break;

         default:
             /* If it ain't HC_SKIP or HC_GETNEXT, pass it along */
             return DefHookProc( nCode, wParam, (LONG)lParam, (FARPROC FAR *)&
             break;
     }
 }
 /*
 */


 KILLTIME.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TIME\KILLTIME.C

 /*
  * Function demonstrated in this program: KillTimer
  * Compiler version: C 5.1
  *
  * Description:
  *   This program demonstrates the use of the KillTimer function. KillTimer
  *   kills the timer event associated with "hWnd" and having the same
  *   event identifier.
  */

 #include "windows.h"

 long   FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   WNDCLASS   HelloClass;

   if (!hPrevInstance)
     {
     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Hello";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Hello",
                      (LPSTR)"KillTimer",
                      WS_OVERLAPPEDWINDOW,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      (HWND)NULL,        /* no parent */
                      (HMENU)NULL,       /* use class menu */
                      (HANDLE)hInstance, /* handle to window instance */
                      (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   SetTimer (hWnd, 100, 500, (FARPROC)NULL);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   KillTimer (hWnd, 100);      /* Kill The Timer */
   return (int)msg.wParam;
   }

 /*************************************************************************/
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_TIMER:
       MessageBeep(0);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LIB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\BIFFLIB\LIB.C

 #include "string.h"
 #include <stdio.h>
 #include "io.h"
 #include "fcntl.h"
 #include "malloc.h"

 #define CONVERT(x,y) (x=y,(char*)&x)
 /* The SHUFFLE macros move the buffer pointer x to a specified
 position y, convert the value there to the proper format, and then
 put the buffer pointer back at its original position */

 #define SHUFFLE(x,y) ((char*)x+y)
 #define ISHUFFLE(x,y) *((int*)((char*)x+y))
 #define DSHUFFLE(x,y) *((double*)((char*)x+y))


 int BIFF_fp;    /* file handle */

 typedef struct {
   unsigned long a:24;
 } ATTR;
 typedef char BYTE;



 int create_BIFF(char *filename)

 /* Creates a new BIFF file, replacing any files by the same name.  The
 entire filename is required (basename + suffix) */

 {
   int i;
   if ((BIFF_fp = open(filename, O_RDWR | O_TRUNC | O_BINARY | O_CREAT, 000040

     /* This section writes the BOF record */
     write(BIFF_fp, CONVERT(i,9), (unsigned)2);
     write(BIFF_fp, CONVERT(i,4), (unsigned)2);
     write(BIFF_fp, CONVERT(i,2), (unsigned)2);
     write(BIFF_fp, CONVERT(i,0x10), 2);
   }
   return(BIFF_fp);
 }

 int open_BIFF(char *filename)
 /* Opens an existing BIFF file in readonly mode */
 {
   return(BIFF_fp = open(filename, O_RDONLY | O_BINARY));
 }

 void dimension_BIFF(int frow, int lrow, int fcol, int lcol)
 /* sets the dimension record in the BIFF file */
 {
   int i;

     /* This section writes the dimension record */
   write(BIFF_fp, CONVERT(i,0), 2);
   write(BIFF_fp, CONVERT(i,8), 2);
   write(BIFF_fp, CONVERT(i,frow), 2);
   write(BIFF_fp, CONVERT(i,lrow+1), 2);
   write(BIFF_fp, CONVERT(i,fcol), 2);
   write(BIFF_fp, CONVERT(i,lcol+1), 2);
 }

 void save_BIFF(int type, int row, int col, char *data)
 /* saves data to a previously created BIFF file */
 {
   unsigned int i;
   static ATTR attribute = {0x000000};

   switch(type) {
     case 1:
       /* Writes a blank cell */
       write(BIFF_fp, CONVERT(i,1), 2);
             write(BIFF_fp, CONVERT(i,7), 2);
       write(BIFF_fp, CONVERT(i,row), 2);
       write(BIFF_fp, CONVERT(i,col), 2);
       write(BIFF_fp, (char *) &attribute, 3);
       break;
     case 2:
       /* Writes integer data */
       write(BIFF_fp, CONVERT(i,2), 2);
             write(BIFF_fp, CONVERT(i,9), 2);
       write(BIFF_fp, CONVERT(i,row), 2);
       write(BIFF_fp, CONVERT(i,col), 2);
       write(BIFF_fp, (char *) &attribute, 3);
       write(BIFF_fp, data, 2);
       break;
     case 4:
       /* Writes data of number type */
       write(BIFF_fp, CONVERT(i,3), 2);
             write(BIFF_fp, CONVERT(i,15), 2);
       write(BIFF_fp, CONVERT(i,row), 2);
       write(BIFF_fp, CONVERT(i,col), 2);
       write(BIFF_fp, (char *) &attribute, 3);
       write(BIFF_fp, data, 8);
       break;
     case 8:
       /* Writes a label */
       write(BIFF_fp, CONVERT(i,4), 2);
             write(BIFF_fp, CONVERT(i,8+strlen(data)), 2);
       write(BIFF_fp, CONVERT(i,row), 2);
       write(BIFF_fp, CONVERT(i,col), 2);
       write(BIFF_fp, (char *) &attribute, 3);
 /* this next write depends on low byte order */
       write(BIFF_fp, CONVERT(i,strlen(data)), 1);
       write(BIFF_fp, data, i);
       break;
     case 16:
       /* Writes boolean type data */
       write(BIFF_fp, CONVERT(i,5), 2);
             write(BIFF_fp, CONVERT(i,9), 2);
       write(BIFF_fp, CONVERT(i,row), 2);
       write(BIFF_fp, CONVERT(i,col), 2);
       write(BIFF_fp, (char *) &attribute, 3);
       write(BIFF_fp, CONVERT(i,(*data?1:0)), 1);
       write(BIFF_fp, CONVERT(i,0), i);
       break;
   }
 }

 int close_BIFF()
 /* Writes an EOF record, and closes the file */
 {
   unsigned long int i = 0x000000a;

   write(BIFF_fp, (char *) &i, 4);
   return(close(BIFF_fp));
 }

 void read_BIFF(int gettype, int (*handler)(int, char *, int))
 /* Reads all data records of a certain type */
 {

   int type;   /* the BIFF type of the currently read record */
   int length;   /* the length of the current record */
   int intype;  /* the Library type of the current record */
   static BYTE buff[2080]; /* buffer containing the current record */
   static int map[7] = {0,1,2,4,8,16,32};
   int typeflag;
   BYTE boolflag;

   /* the map array serves to map the BIFF record types (e.g.
     label = record type 4) to the Library record type
     (where label = type 8)
   */

   do {
     read(BIFF_fp, (char *)&type, 2);
     read(BIFF_fp, (char *)&length, 2);
     intype = map[(type<7&&type>0) ? type : 0];
     switch((gettype & intype) | (intype & 32)) {
       case 1: case 2: case 4: case 8: case 16:
         read(BIFF_fp, (char *) buff, length);
         (*handler)(intype, (char *) buff, length);
         break;
       case 32:
         read(BIFF_fp, (char *) buff, length);
         typeflag = ISHUFFLE(buff, 13);
         boolflag = *SHUFFLE(buff, 7);
         if (typeflag == 0xFFFF) {
             if ((boolflag == 1) && (gettype & 16))
                 (*handler)(16, (char *) buff, length);
         } else if (gettype & 4)
           (*handler)(4, (char *) buff, length);
         break;
       default:
         lseek(BIFF_fp, (long) length, SEEK_CUR);
       }
   } while(type != 0x0A);
 }


 int find_BIFF(int gettype, int row, int col, int (*handler)(int, char *, int)
 {

   int type;     /* the BIFF record type of the current record */
   int intype;      /* the Library record type of the current record */
   int length;     /* the length of the current record */
   int rw, cl;     /* the row and column of the current record */
   int flag = 0;     /* used to determine if this is the first row
         record in a certain block */
   int rwMic, rwMac;  /* the first and last(+1) row in a document */
   int colMic, colMac; /*the first and last(+1) column in a certain row*/
   int dbRtcell;     /* the offset of the current row records */
   long int offset;   /* the cumulative offset for the row record */
   static BYTE buff[2080]; /* buffer containing the record contents */
   static long blockbuff[100];
         /* contains row block indices, size is arbitrary */
   static int map[7] = {0,1,2,4,8,16,32};
         /* Maps BIFF record types to Library record types */
   int typeflag;
   BYTE boolflag;

   /* Read the index record */
   lseek(BIFF_fp, 8L, SEEK_SET);
   read(BIFF_fp, (char *)&type, 2);
   if (type != 0x0B)
     return(1);
   read(BIFF_fp, (char *)&length, 2);
   lseek(BIFF_fp, 4L, SEEK_CUR);
   read(BIFF_fp, (char *)&rwMic, 2);
   read(BIFF_fp, (char *)&rwMac, 2);
   if(col < rwMic || col > rwMac-1)
     return(2);
   read(BIFF_fp, (char *)blockbuff, (rwMac-1-rwMic));

   /* move to the proper row block */
   lseek(BIFF_fp, blockbuff[(row-rwMic)/32] , SEEK_SET);
   do {
     /* Read the current Row record */
     read(BIFF_fp, (char *)&type, 2);
     if (type != 0x08)
       return(3);
     read(BIFF_fp, (char *)&length, 2);
     read(BIFF_fp, (char *)&rw, 2);
     read(BIFF_fp, (char *)&colMic, 2);
     read(BIFF_fp, (char *)&colMac, 2);

     lseek(BIFF_fp, 5L, SEEK_CUR);
     read(BIFF_fp, (char *)&dbRtcell, 2);

     /* If rgbAttr field is present, move over it */
     if (length == 20)
       lseek(BIFF_fp, 3L, SEEK_CUR);

     /* update offset (see BIFF document section
     "Finding Cell Values" for more information */
     if (flag == 0) {
       offset = tell(BIFF_fp) + dbRtcell;
       flag = 1;
     } else
       offset += dbRtcell;
   } while (rw < row);

   if (rw == row) {
     if (col < colMic || col > colMac)
       return(4);
     lseek(BIFF_fp, offset, SEEK_SET);

     /* Read the row's records until the proper column is reached*/
     do {
       read(BIFF_fp, (char *)&type, 2);
       read(BIFF_fp, (char *)&length, 2);
       read(BIFF_fp, (char *)&rw, 2);
       read(BIFF_fp, (char *)&cl, 2);
       lseek(BIFF_fp, (long)(length-4), SEEK_CUR);
     }  while (cl < col);

     if (cl == col) {
       /* Proper record is found.  Call handler routine */
       intype = map[(type<7&&type>0) ? type : 0];
       switch((gettype & intype) | (intype & 32)) {
           case 1: case 2: case 4: case 8: case 16:
         lseek(BIFF_fp, (long)(-length), SEEK_CUR);
         read(BIFF_fp, (char *) buff, length);
         (*handler)(intype, (char *) buff, length);
         return(0);
           case 32:
         lseek(BIFF_fp, (long)(-length), SEEK_CUR);
         read(BIFF_fp, (char *) buff, length);
         typeflag = ISHUFFLE(buff, 13);
         boolflag = *SHUFFLE(buff, 7);
         if (typeflag == 0xFFFF) {
             if ((boolflag == 1) && (gettype & 16))
                 (*handler)(16, (char *) buff, length);
         } else if (gettype & 4)
           (*handler)(4, (char *) buff, length);
         return(0);

       }
     }
   }
   return(5);
 }




 void get_blank(char *data, int *row, int *col)
 {

   *row = ISHUFFLE(data,0);
   *col = ISHUFFLE(data,2);
 }

 void get_integer(char *data, int *row, int *col, unsigned int *value)
 {
   int *ptr;

   *row = ISHUFFLE(data,0);
   *col = ISHUFFLE(data,2);
   *value = ISHUFFLE(data,7);

 }

 void get_number(char *data, int *row, int *col, double *value)
 {
   /* We do not have to check for the formula record case because the
      number value begins at the seventh byte in both cases. */

   *row = ISHUFFLE(data,0);
   *col = ISHUFFLE(data,2);
   *value = DSHUFFLE(data,7);
 }

 void get_label(char *data, int *row, int *col, char **string)
 {
   int length;

   *row = ISHUFFLE(data,0);
   *col = ISHUFFLE(data,2);
   length = *SHUFFLE(data,7);
   *string = (char *) malloc((length+1) * sizeof(char));
   strncpy(*string, SHUFFLE(data,8), length);
   strncpy((char*)*string+length, '\0', 1);
 }

 void get_bool(char *data, int *row, int *col, int *value)
 {
   int typeflag;

   *row = ISHUFFLE(data,0);
   *col = ISHUFFLE(data,2);
   typeflag = ISHUFFLE(data, 13);
   if (typeflag == 0xFFFF)
     *value = *SHUFFLE(data, 9);
   else
     *value = *SHUFFLE(data,7);
 }


 LINEDDA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\LINEDDA.C

 /*
  *   LineDDA
  *
  *   This program demonstrates the use of the LineDDA function. LineDDA
  *   performs a function for every point on the line from X1,X2 to Y1,Y2.
  *   LineDDA is called from Winmain in this sample application.
  */

 #include "windows.h"

 HDC hDC;

 long FAR PASCAL HelloWndProc(HWND, unsigned, WORD, LONG);

 void FAR PASCAL DrawLine(int,int,LPSTR);


 /****************** procedure that LineDDA "calls" *********************/

 void FAR PASCAL DrawLine(X,Y,lpData)
 int X;
 int Y;
 LPSTR lpData;

 {
 switch (X % 3)
     {
     case 0:
        MoveTo(hDC,X+30,Y-1);
        LineTo(hDC,X-1,Y+11);
        break;

     default:
        break;
     }
 return;
 }

 /***********************************************************************/


 /* Procedure called when the application is loaded for the first time */
 BOOL HelloInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pHelloClass;

     pHelloClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pHelloClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pHelloClass->hIcon    = LoadIcon( hInstance,NULL);
     pHelloClass->lpszMenuName   = (LPSTR)NULL;
     pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
     pHelloClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pHelloClass->hInstance      = hInstance;
     pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
     pHelloClass->lpfnWndProc    = HelloWndProc;

     if (!RegisterClass( (LPWNDCLASS)pHelloClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pHelloClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     HelloInit( hInstance );
     hWnd = CreateWindow((LPSTR)"Sample Application",
       (LPSTR)"LineDDA",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     hDC = GetDC(hWnd);

 /************************    call LineDDA    **************************/

     LineDDA(0,0,200,200,(FARPROC)DrawLine,(LPSTR)NULL);

 /**********************************************************************/

     ReleaseDC(hWnd,hDC);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL HelloWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
   return DefWindowProc( hWnd, message, wParam, lParam );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 LINETO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\LINETO.C

 /*
  * Function demonstrated in this program: LineTo
  *
  * Description:
  *   This program demonstrates the use of the LineTo () function.
  *   LineTo () draws a line from the current position up to, but not includin
  *   the point specified by X, Y. It also updates the current position to X,
  *   In this program, LineTo () is called in response to a WM_PAINT message
  *   in HelloWndProc ().
  *
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG       msg;
   HWND      hWnd;
   HMENU     hMenu;
   WNDCLASS  HelloClass;

   if (!hPrevInstance)
     {
     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"LineTo";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"LineTo",
                       (LPSTR)"LineTo ()",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       (HWND)NULL,           /* no parent */
                       (HMENU)NULL,          /* use class menu */
                       (HANDLE)hInstance,    /* handle to window instance */
                       (LPSTR)NULL);         /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /* Procedures which make up the window class. */
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT ps;

   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);

       MoveTo (ps.hdc, 100, 10);    /*  move current position to 100, 10 */
       LineTo (ps.hdc, 100, 200);   /*  draw from 100, 10 to 10, 200      */
       MoveTo (ps.hdc, 200, 10);    /*  move current position to 200, 10 */
       LineTo (ps.hdc, 200, 200);   /*  draw from 200, 10 to 200, 200     */
       LineTo (ps.hdc, 300, 10);    /* draw to 300, 10                      */

       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LNOTIFY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\LNOTIFY.C

 /**************************************************************************
  * LNOTIFY.C - Demo Program for LocalNotify.
  *
  *
  * Compiled with MS C 5.1 & Windows SDK 2.03
  * Compiled on IBM-AT with 640K RAM.
  *
  **************************************************************************/

 #include <windows.h>

 /* PROTOTYPES */
 int  PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
 BOOL FAR PASCAL NotifyProc(WORD, HANDLE, WORD);

 FARPROC  lpNotifyProc;
 FARPROC  oldNotifyProc;

 /***************************************************************************/

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 LPSTR    lpszCmdLine;
 int  cmdShow;
 {
   HANDLE   hMem;

   MessageBox(GetFocus(),
       (LPSTR)"This is a program to demonstrate LocalNotify. About to swap Not
       (LPSTR)"LocalNotify",
       MB_OK);

 /* Get a relocatable procedure address. */
   lpNotifyProc = MakeProcInstance((FARPROC)NotifyProc, hInstance);

 /* Replace the local-heap notification handler */
   oldNotifyProc = LocalNotify(lpNotifyProc);

   MessageBox(GetFocus(),
       (LPSTR)"About to send a message to the new Notify Procedure.",
       (LPSTR)"LocalNotify",
       MB_OK);

   hMem = LocalAlloc(LMEM_DISCARDABLE | LHND, 1024);  /* Request a 1K buffer.

   FreeProcInstance(LocalNotify(oldNotifyProc));                 /* Clean up.

   MessageBox(GetFocus(), (LPSTR)"Finished", (LPSTR)"LocalNotify", MB_OK);

   return (0);
 } /* WINMAIN */


 /***************************************************************************/
 /*  NOTIFYPROC:  Local memory discarding notification procedure. */

 BOOL FAR PASCAL NotifyProc(function, arg1, arg2)
 WORD   function;
 HANDLE arg1;
 WORD   arg2;
 {
   switch (function)
   {

   case LNOTIFY_OUTOFMEM:

     MessageBox(GetFocus(),
         (LPSTR)"Out of memory message received by new Notify Procedure.",
         (LPSTR)"LocalNotify",
         MB_OK);
     return(0);
     break;

   default:
     break;
   }
   return(arg2);
 }





 LOADACC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ACCELL\LOADACC.C

 /*
  *   LoadAccelerators
  *
  *   This program demonstrates the use of the LoadAccelerators function.
  *   The LoadAccelerators function loads an accelerator table. In this
  *   program, LoadAccelerators in called in LoadAccWindProc. The two
  *   accelerators that are loaded are ^A and ^B, which are accelerators
  *   for the menu choices "CHOICE1" and "CHOICE2."
  */

 #include <windows.h>
 #include "loadacc.h"

 long    FAR PASCAL LoadAccWndProc (HWND, unsigned, WORD, LONG);

 static HANDLE hAccelTable;        /*  handle to accelerator table  */

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   LoadAccClass;

     LoadAccClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     LoadAccClass.hIcon          = LoadIcon (hInstance, NULL);
   /*---------------------- important for adding menu ------------------------
     LoadAccClass.lpszMenuName   = (LPSTR)"example";
   /*-------------------------------------------------------------------------
     LoadAccClass.lpszClassName  = (LPSTR)"Sample Application";
     LoadAccClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     LoadAccClass.hInstance      = hInstance;
     LoadAccClass.style          = CS_HREDRAW | CS_VREDRAW;
     LoadAccClass.lpfnWndProc    = LoadAccWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&LoadAccClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
       (HMENU)NULL,       /* use class menu */
       (HANDLE)hInstance, /* handle to window instance */
       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
 /* if translation of accelerator succesful */
     if (TranslateAccelerator (msg.hwnd, hAccelTable, (LPMSG) & msg) == 0)
       {
       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
       }
     }
   return (int)msg.wParam;
   }

 /* Procedures which make up the window class. */
 long    FAR PASCAL LoadAccWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   PAINTSTRUCT    ps;
   TEXTMETRIC     tm;
   static short   Xchar, Ychar;
   HDC            hDC;
   HANDLE         hInstance;

   switch (message)
     {
     case WM_CREATE:
       hDC = GetDC (hWnd);
       GetTextMetrics (hDC, &tm);
       Xchar = tm.tmAveCharWidth;
       Ychar = tm.tmHeight + tm.tmExternalLeading;
       ReleaseDC (hWnd, hDC);
       hInstance = GetWindowWord (hWnd, GWW_HINSTANCE);
   /**** Load the accelerator table ***/
       hAccelTable = LoadAccelerators (hInstance, (LPSTR)"example");
       if (!hAccelTable)      /* if accelerator table not properly loaded */
         return FALSE;
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case CHOICE1:   /** can be chosen with accelerator ^A **/
           MessageBox (hWnd, (LPSTR)"CHOICE1 has been chosen",
               (LPSTR)"MENU INFO", MB_OK);
           break;

         case CHOICE2:   /** can be chosen with accelerator ^B **/
           MessageBox (hWnd, (LPSTR)"CHOICE2 has been chosen",
               (LPSTR)"MENU INFO", MB_OK);
           break;

         default:
           break;
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     case WM_PAINT:
       BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       TextOut (ps.hdc, Xchar, Ychar,
           (LPSTR)"To test accelerators press ^A or ^B", 35);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LOADCURS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\LOADCURS.C

 /*
  *   LoadCursor
  *
  *   This program demonstrates the use of the LoadCursor function. The
  *   LoadCursor function loads either a standard windows cursor or a user
  *   defined cursor created with the Icon Editor. LoadCursor is called in
  *   LoadCursInit in this sample application.
  */

 #include "windows.h"

 long    FAR PASCAL LoadCursWndProc (HWND, unsigned, WORD, LONG);
 int     PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
 BOOL FAR PASCAL About (HWND, unsigned, WORD, LONG);

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   LoadCursClass;

   /*----------------------- Invoke LoadCursor -------------------------------
     LoadCursClass.hCursor        = LoadCursor (hInstance, "mycursor");
   /*-------------------------------------------------------------------------
     LoadCursClass.hIcon          = LoadIcon (hInstance, NULL);
     LoadCursClass.lpszMenuName   = (LPSTR)NULL;
     LoadCursClass.lpszClassName  = (LPSTR)"Sample Application";
     LoadCursClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     LoadCursClass.hInstance      = hInstance;
     LoadCursClass.style          = CS_HREDRAW | CS_VREDRAW;
     LoadCursClass.lpfnWndProc    = LoadCursWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&LoadCursClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application",
       (LPSTR)"LoadCursor Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
       (HMENU)NULL,       /* use class menu */
       (HANDLE)hInstance, /* handle to window instance */
       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }


 /***************************************************************************/
 long    FAR PASCAL LoadCursWndProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
   /* Remove the cursor bitmap from memory or decrement the
            * reference count if it is greater than 1.
            */
       FreeResource (GetClassWord (hWnd, GCW_HCURSOR));
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LOADICON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ICON\LOADICON.C

 /*
 Function(s) demonstrated in this program: LoadIcon
 Description:  This function loads an icon.
 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "LoadIcon.h"

 HWND     hWndParent1;
 HANDLE   hInstMain;

 char  szOutputBuffer1 [70];
 char  szOutputBuffer2 [500];

 struct {
   char  *szMessage;
 } Messages [] = {
   "About\0",
   "     This is a sample application to demonstrate the\
 use of the LoadIcon Windows function.",

   "Help Message",
   "     This program uses the LoadIcon Windows function\
 to load the icon for this window.  Iconize this window\
 to see if the function worked",

 };


 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
 HWND     hWnd;
 int  MessageNumber;
 {
   sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
   sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
   MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }


 /****************************************************************************

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int  nCmdShow ;
 {
   static char  szAppName [] = "LoadIcon" ;
   HWND        hWnd ;
   WNDCLASS    wndclass ;
   MSG msg;
   short  xScreen, yScreen ;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (hInstance, szAppName) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = szAppName ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
       return FALSE ;
   }

   xScreen = GetSystemMetrics (SM_CXSCREEN) ;
   yScreen = GetSystemMetrics (SM_CYSCREEN) ;

 hWndParent1 = CreateWindow (szAppName,     /* window class name       */
 "LoadIcon",                 /* window caption          */
 WS_OVERLAPPEDWINDOW,        /* window style            */
 CW_USEDEFAULT,              /* initial x position      */
 0,                          /* initial y position      */
 CW_USEDEFAULT,              /* initial x size          */
 0,                          /* initial y size          */
 NULL,                       /* parent window handle    */
 NULL,                       /* window menu handle      */
 hInstance,                  /* program instance handle */
   NULL) ;                     /* create parameters       */

   ShowWindow (hWndParent1, nCmdShow) ;
   UpdateWindow (hWndParent1) ;

   hInstMain = hInstance;

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 /****************************************************************************

 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   HMENU       hMenu;
   HDC         hDC;
   PAINTSTRUCT ps;
   static int  xClient, yClient;
   switch (iMessage)
   {
   case WM_CREATE:
     hMenu = GetSystemMenu (hWnd, FALSE);

     ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
         MF_APPEND | MF_STRING);
     break;

   case WM_SYSCOMMAND:
     switch (wParam)
     {
     case IDM_ABOUT:
       ProcessMessage (hWnd, 0);
       break;
     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
     break;

   case WM_COMMAND:
     switch (wParam)
     {
     case IDM_HELP:
       ProcessMessage (hWnd, 2);
       break;
     }
     break;

   case WM_PAINT:
     BeginPaint(hWnd, (LPPAINTSTRUCT) & ps);
     EndPaint(hWnd, (LPPAINTSTRUCT) & ps);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
   }
   return (0L);
 }





 LOADMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\LOADMENU.C

 /*
  *   LoadMenu
  *
  *   This program demonstrates the use of the LoadMenu function.
  *   LoadMenu loads a menu resource into memory. To put the menu resource
  *   in a window, SetMenu must be called after LoadMenu.
  */

 #include "windows.h"

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;

   if (!hPrevInstance)
     {
     WNDCLASS   HelloClass;

     HelloClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     HelloClass.hIcon          = LoadIcon (hInstance, NULL);
     HelloClass.lpszMenuName   = (LPSTR)NULL;
     HelloClass.lpszClassName  = (LPSTR)"Sample Application";
     HelloClass.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
     HelloClass.hInstance      = hInstance;
     HelloClass.style          = CS_HREDRAW | CS_VREDRAW;
     HelloClass.lpfnWndProc    = HelloWndProc;

     if (!RegisterClass ( (LPWNDCLASS)&HelloClass))
       return FALSE;
     }

   hWnd = CreateWindow ( (LPSTR)"Sample Application",
       (LPSTR)"LoadMenu Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
       (HMENU)NULL,       /* use class menu */
       (HANDLE)hInstance, /* handle to window instance */
       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   MessageBox (hWnd, (LPSTR)"call LoadMenu", (LPSTR)"I am about to...", MB_OK)

   hMenu = LoadMenu (hInstance, "loadmenu");       /* Load menu into memory */

   if (!hMenu)
     MessageBox (hWnd, (LPSTR)"LoadMenu failed", (LPSTR)NULL, MB_OK);
   else
     SetMenu (hWnd, hMenu); /* put the menu in the window */

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /**************************************************************************/
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LOADRES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\LOADRES.C

 /*
  *
  *  LoadResource
  *
  *  This program demonstrates the use of the function LoadResource.
  *  This function removes a loaded resource from memory by freeing
  *  the allocated memory occupied by that resource.
  */

 #include "windows.h"

 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   HANDLE hResInfo;
   HANDLE hResData;
   HANDLE hLib;
   BOOL bFreed;
   LPSTR lpResInfo;

   hLib = LoadLibrary( (LPSTR)"lib.exe" );
   hResInfo = FindResource( hLib, MAKEINTRESOURCE(63), RT_STRING );

   MessageBox (NULL, (LPSTR)"Loading resource", (LPSTR)"ok", MB_OK);

   hResData = LoadResource ( hLib, hResInfo );

   if ( hResData != NULL )
     MessageBox (NULL, (LPSTR)"Resource loaded", (LPSTR)"ok", MB_OK);
   else
     MessageBox (NULL, (LPSTR)"Resource not loaded", (LPSTR)"ok", MB_OK);

   bFreed = FreeResource ( hResData );
   return 0;
 }




 LOADSTR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\LOADSTR.C

 /*
  *   LoadString
  *
  *   This program demonstrates the use of the LoadString function. The
  *   LoadString Function loads string resources identified by the second
  *   parameter. In this sample application, the string resource identifiers
  *   are STRING1 and STRING2.
  *
  */

 #include <windows.h>
 #include "loadstr.h"

 char  szBuffer[26];   /* buffer to hold strings loaded via LoadString  */

 long    FAR PASCAL HelloWndProc (HWND, unsigned, WORD, LONG);

 /***************************************************************************/
 /* Procedure called when the application is loaded for the first time */

 BOOL HelloInit (hInstance)
 HANDLE hInstance;
   {
   PWNDCLASS   pHelloClass;

   pHelloClass = (PWNDCLASS)LocalAlloc (LMEM_FIXED, sizeof (WNDCLASS));

   pHelloClass->hCursor        = LoadCursor (NULL, IDC_ARROW);
   pHelloClass->hIcon                 = LoadIcon (hInstance, NULL);
   pHelloClass->lpszMenuName   = (LPSTR)NULL;
   pHelloClass->lpszClassName  = (LPSTR)"Sample Application";
   pHelloClass->hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   pHelloClass->hInstance      = hInstance;
   pHelloClass->style          = CS_HREDRAW | CS_VREDRAW;
   pHelloClass->lpfnWndProc    = HelloWndProc;

   if (!RegisterClass ( (LPWNDCLASS)pHelloClass))
     return FALSE;

   LocalFree ( (HANDLE)pHelloClass);
   return TRUE;        /* Initialization succeeded */
   }


 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   MSG   msg;
   HWND  hWnd;
   HMENU hMenu;
   int  sizeString;  /* holds return value from LoadString */

   if (!hPrevInstance)
     HelloInit (hInstance);

   hWnd = CreateWindow ( (LPSTR)"Sample Application",
       (LPSTR)"Sample Application",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,      /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
  );

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

 /* attempt to load string with identifier STRING1 */
   sizeString = LoadString (hInstance, STRING1, (LPSTR)szBuffer, 25);

   if (sizeString > 0)  /* if string with STRING1 identifier exists */
     MessageBox (hWnd, (LPSTR)szBuffer,
         (LPSTR)"The following string came via LoadString", MB_OK);
   else
     MessageBox (hWnd, (LPSTR)"No such string resource exists",
         (LPSTR)"ERROR", MB_OK);

 /* attempt to load string with identifier STRING2 */
   sizeString = LoadString (hInstance, STRING2, (LPSTR)szBuffer, 25);

   if (sizeString > 0) /* if string with STRING2 identifier exists */
     MessageBox (hWnd, (LPSTR)szBuffer,
         (LPSTR)"The following string came via LoadString", MB_OK);
   else
     MessageBox (hWnd, (LPSTR)"No such string resource exists",
         (LPSTR)"ERROR", MB_OK);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   return (int)msg.wParam;
   }

 /***************************************************************************/
 long    FAR PASCAL HelloWndProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
   {
   switch (message)
     {
     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 LOCALHAN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCALHAN.C

 /*
  *  Function (s) demonstrated in this program: LocalHandle
  *  Description:
  *     This program will demonstrate the use of the LocalHandle function.
  *  It will allocate memory using LocalAlloc, get a pointer to that
  *  memory, and then check to make sure that LocalHandle returns the
  *  same handle that LocalAlloc did.
  *
  */

 #include <windows.h>

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 /***************************************************************************/
 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
   {
   HANDLE      hLocalMem;          /*  Handle to Local Memory  */
   HANDLE      hLocalHandleMem;    /*  Will hold returned handle  */
   PSTR        pszLocalMem;       /*  Near Pointer to memory  */

   hLocalMem = LocalAlloc (LMEM_MOVEABLE, 40);         /* Allocate memory */
   pszLocalMem = (PSTR) LocalLock (hLocalMem);         /* Get a pointer   */
   hLocalHandleMem = LocalHandle ( (WORD) pszLocalMem);

 /*  Get the handle to the memory  */
   if (hLocalHandleMem == hLocalMem)
     MessageBox (GetFocus (), (LPSTR)"The two handles match", (LPSTR)"", MB_OK
   else
     MessageBox (GetFocus (), (LPSTR)"The two handles don't match",
         (LPSTR)"", MB_OK);

   LocalUnlock (hLocalMem);                          /* Unlock the memory */
   LocalFree (hLocalMem);                            /* Free the memory   */

   return (0L);
   }


 LOCFLAG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCFLAG.C

 /*
  *  LocalFlags
  *
  *  This program demonstrates the use of the LocalFlags function. The
  *  program will allocate some memory using LocalAlloc, and then tell
  *  the user if that memory block has been discarded or if it is marked
  *  as discarded.
  */

 #include <windows.h>

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;         /*  The memory block */
   WORD    wFlags;          /*  Return Value from function */
   char  szBuffer[80];   /*  Temporary Buffer for a string */
   int   sprintf ();          /*  Tell the compiler what will
                          *  be returned.
                            */

 /*  Allocate 40 bytes of moveable, discardable memory and initialize
   *  all of the bytes to 0.
   */
   hMemBlock = LocalAlloc (LMEM_ZEROINIT | LMEM_MOVEABLE | LMEM_DISCARDABLE,
       (WORD) 40);

   wFlags = LocalFlags (hMemBlock);   /*  Get the info from LocalFlags  */

   if (wFlags & LMEM_DISCARDED)
     MessageBox (NULL, (LPSTR)"The allocated memory has been discarded.",
         (LPSTR)"Ok", MB_OK);

   if (wFlags & LMEM_DISCARDABLE)
     MessageBox (NULL, (LPSTR)"The allocated memory is discardable.",
         (LPSTR)"Ok", MB_OK);

   sprintf (szBuffer, "The Reference Count is %d",
       wFlags & LMEM_LOCKCOUNT);
 /*  Masking out the lock or reference count  */

   MessageBox (NULL, (LPSTR) szBuffer, (LPSTR) "Ok", MB_OK);
 /*  Display the lock count via a message box  */

   return 0;
   }


 LOCFREE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCFREE.C

 /*
  *  LocalFree
  *
  *  This program demonstrates the use of the function LocalFree.  It
  *  allocates a block of memory, using LocalAlloc, and then simply
  *  frees the block.
  */

 #include <windows.h>

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)

 HANDLE  hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;    /*  The memory block  */
   WORD  Flags;        /*  Return Value from function  */

 /*  Allocate 40 bytes of moveable, discardable memory and initialize
   *  all of the bytes to 0.
   */
   hMemBlock = LocalAlloc (LMEM_ZEROINIT | LMEM_MOVEABLE | LMEM_DISCARDABLE,
       (WORD) 40);

   hMemBlock = LocalFree (hMemBlock);  /* Free the block of memory
                                    * and put the return code into
                                     * hMemBlock.
                                      */

   if (hMemBlock == NULL)
     MessageBox (NULL, (LPSTR)"LocalFree function Successful",
         (LPSTR)"OK", MB_OK);
 /*  Tells user if successful  */
   else
     MessageBox (NULL, (LPSTR)"LocalFree function Unsuccessful",
         (LPSTR)"OK", MB_OK);
 /*  Tells user if not successful  */

   return 0;
   }


 LOCINIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCINIT.C

 /**************************************************************************
  *  LOCINIT  version 1.00
  *
  * This program tests the LocalInit function, which initializes the local
  * heap at the specified segment location with the specified amount of
  * memory for the heap.
  *
  **************************************************************************/

 #include <windows.h>
 #include <stdio.h>

 #define  HEAPSIZE  1024
 #define  HEAPSEG  0

 char  szPurpose[80] = "This is a program to initialize the local heap";
 HANDLE  hLocMem;

 /**************************************************************************/

 int     PASCAL  WinMain (HANDLE, HANDLE, LPSTR, int);
 BOOL              LocInit (HANDLE);
 long    FAR PASCAL      LocInitWndProc (HWND, unsigned, WORD, LONG);

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE  hInstance;
 HANDLE  hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;
   BOOL  Init;
   HANDLE  hInst;
   HWND  hWnd;
   char  MesBuf[80];
   WORD  wMemsize;

   MessageBox (GetFocus (), (LPSTR)szPurpose, (LPSTR)"LOCINIT", MB_OK);

   if (!hPrevInstance)
 /* Ensure that windows knows where to find parts of this
      * task on disk by Registering a window class. Registering
                  * a class binds an executable name to an internal name,
      * known to Windows. */
     if (LocInit (hInstance) == FALSE)
       return FALSE;

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR) "locinit", /* Window class name */
   (LPSTR) "locinit", /* Window title */
   WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,               /* No parent */
   (HMENU)NULL,       /* Use the class menu */
   (HANDLE)hInstance,  /* .EXE file for Class */
   (LPSTR)NULL           /* No Parameters */
  );

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);             /* Paint the client area */

   wMemsize = LocalSize (hLocMem);

   sprintf (MesBuf, "New size of local heap: %d\nLocated at Segment: %d",
       HEAPSIZE, HEAPSEG);

   MessageBox (hWnd, (LPSTR)MesBuf, (LPSTR)"LocalInit", MB_OK);

   MessageBox (hWnd, (LPSTR)"Initialized and Accessed Local Heap Succesfully",
       (LPSTR)"LocalInit", MB_OK);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 /* WINMAIN */
 /***************************************************************************/

 BOOL    LocInit (hInstance)
 HANDLE  hInstance;
   {
   NPWNDCLASS  npLocInitClass;
   BOOL      bLocInit;

   bLocInit = LocalInit ( (WORD)HEAPSEG, (WORD)0, (char *)HEAPSIZE);

   if (!bLocInit)
     MessageBox (GetFocus (), (LPSTR)"Local Initialization of Heap failed",
         (LPSTR)"LOCINIT", MB_ICONHAND | MB_OK);
   return FALSE;

   hLocMem = LocalAlloc (LMEM_DISCARDABLE, sizeof (WNDCLASS));
   npLocInitClass = (NPWNDCLASS)LocalLock (hLocMem);

   npLocInitClass->hCursor       = LoadCursor (NULL, IDC_ARROW);
   npLocInitClass->hIcon         = NULL;
   npLocInitClass->lpszMenuName  = (LPSTR)NULL;
   npLocInitClass->lpszClassName = (LPSTR)"LocInit";
   npLocInitClass->hbrBackground = (HBRUSH)GetStockObject (WHITE_BRUSH);
   npLocInitClass->hInstance     = hInstance;
   npLocInitClass->style         = CS_HREDRAW | CS_VREDRAW;
   npLocInitClass->lpfnWndProc   = LocInitWndProc;
   npLocInitClass->cbClsExtra    = 0;
   npLocInitClass->cbWndExtra    = 0;

   if (!RegisterClass ( (NPWNDCLASS)npLocInitClass))
 /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
     return (FALSE);

   return (TRUE);

   }


 /* END locinitINIT */

 /***************************** WINDOWPROC *****************************/
 /*  Every message dispatched to any window of type "locinit" will
  *  result in a call to this procedure.
  */
 long    FAR PASCAL LocInitWndProc (hWnd, identifier, wParam, lParam)
 HWND    hWnd;    /* Intended window */
 unsigned  identifier;  /* Message Number */
 WORD    wParam;    /* 16 bit param */
 LONG    lParam;    /* 32 bit param */
   {
   switch (identifier)
     {
     default:
       return DefWindowProc (hWnd, identifier, wParam, lParam);
       break;
     }

   return (0L);
   } /* windowproc */


 LOCKRES.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\LOCKRES.C

 /*
  * Function (s) demonstrated in this program: LockResource
  *
  * Description:
  * This program uses a text file to store text which is brought in at
  * run time.  The functions FindResource and LoadResource are used to
  * place this text into memory.  Once it is in memory the function
  * LockResource is used to create a long pointer to the text so it can
  * be accessed.  LockResource also locks the text into the current
  * memory block so the long pointer will not become invalid.  Then the
  * text is massaged and output via a messagebox.
  *
 */

 #include <windows.h>
 #include "lockres.h"

 static char  szFuncName [] = "LockResource";
 static char  szAppName  [] = "LOCKRES";
 static HANDLE   hInst;

 /***************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance;
 HANDLE      hPrevInstance;
 LPSTR       lpszCmdLine;
 int  nCmdShow;
   {
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG         msg;
   HMENU       hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = (LPSTR)"Lock";
     wndclass.lpszClassName = szFuncName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hInst = hInstance;
   hMenu = LoadMenu (hInstance, (LPSTR)"Lock");

 hWnd = CreateWindow (szFuncName,           /* window class name       */
 szAppName,                  /* window caption          */
 WS_OVERLAPPEDWINDOW,        /* window style            */
 CW_USEDEFAULT,              /* initial x position      */
 0,                          /* initial y position      */
 CW_USEDEFAULT,              /* initial x size          */
 0,                          /* initial y size          */
 NULL,                       /* parent window handle    */
 hMenu,                      /* window menu handle      */
 hInstance,                  /* program instance handle */
   NULL);                      /* create parameters       */

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }


 /***************************************************************************/

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC         hDC;
   HANDLE      hResource;
   LPSTR       lpText;
   LPSTR       lpTextTrunc;
   int  nIndex1;
   int  nIndex2;

   switch (iMessage)
     {
     case WM_INITMENU:
       InvalidateRect (hWnd, NULL, TRUE);
       break;

     case WM_COMMAND:
       switch (wParam)
         {
         case IDM_RES:
           hDC = GetDC (hWnd);
     /* Move the text into memory */
           hResource = LoadResource (hInst, FindResource (hInst,"Sample", "TEX

     /* Locking the text and creating a long pointer to it */
           lpText = LockResource (hResource);

     /* Massaging the text */
           lpTextTrunc = lpText;
           while (*lpTextTrunc != '\0' && *lpTextTrunc++ != '~');
             if (*lpTextTrunc != '\0')
               {
               lpTextTrunc--;
               *lpTextTrunc = '\0';
               }

     /* Outputting the text */
           MessageBox (hWnd, lpText, (LPSTR)szFuncName, MB_OK);

           FreeResource (hResource);
           ReleaseDC (hWnd, hDC);
           break;

         default:
           return DefWindowProc (hWnd, iMessage, wParam, lParam);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 LOCLALLO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCLALLO.C

 /*
  *   LocalAlloc
  *
  *   This program demonstrates the use of the LocalAlloc function.
  *   The LocalAlloc function allocates space for use in the local heap.
  */

 #include <windows.h>

 int sprintf();

 typedef struct {    /* structure we are going */
     int x;    /* to allocate and lock   */
     int y;
          } MYSTRUCT;

 typedef MYSTRUCT *lpMyPtr;  /* far pointer to MYSTRUCT type */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE hMemBlock;    /* Handle to memory block       */
     lpMyPtr  ThisPtr;    /* Pointer to MYSTRUCT structure   */
     char szBuff[80];    /* buffer for message box       */

 /* allocate space in global heap for a MYSTRUCT structure */
     hMemBlock = LocalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE,
         (long)sizeof(MYSTRUCT));

 /* if memory allocated properly */
     if (hMemBlock != NULL)
   {
   MessageBox(NULL,(LPSTR)"The memory was allocated properly",
       (LPSTR)" ",MB_OK);

   /* lock memory into current address */
   ThisPtr = (lpMyPtr)LocalLock(hMemBlock);

   /* if lock worked */
   if (ThisPtr != NULL)
       {
       /* use memory from global heap and output results*/
       ThisPtr->x = 4;
       ThisPtr->y = 4;
       ThisPtr->x = ThisPtr->x*ThisPtr->y;
       sprintf(szBuff,"ThisPtr->x * ThisPtr->y = %d",ThisPtr->x);
       MessageBox(NULL,(LPSTR)szBuff,
           (LPSTR)"Info from LocalAlloc'ed memory",
           MB_OK);
       LocalUnlock(hMemBlock);    /* unlock block */
       LocalFree(hMemBlock);      /* free block   */
       }
   else ;
   }
     else
   MessageBox(NULL,(LPSTR)"The memory was not allocated",
       (LPSTR)" ",MB_OK);
     return 0;
 }


 LOCLCMPC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCLCMPC.C

 /*
  *   LocalCompact
  *
  *   This program demonstrates the use of the LocalCompact function. The
  *   LocalCompact function compacts the global heap. LocalCompact was
  *   called from WinMain in this sample application.
  */

 #include "windows.h"

 int sprintf();

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HANDLE    hMemBlock1;    /* Handle to memory block */
     HANDLE    hMemBlock2;    /* Handle to memory block */
     char szBuff[90];
     WORD ContigFreeBytes;
     char NEAR *   Rasta1, Rasta2;

 /* LocalCompact to ask for 4096 continguous bytes */
     ContigFreeBytes = (WORD)LocalCompact((WORD)4096);
     sprintf(szBuff,"Number of contiguous free bytes before allocation = %u",
                   ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)" ",MB_OK);

 /* Allocate 2 bytes from global heap */
     hMemBlock1 = LocalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DISCARDABLE,
         (long)2);
 /* if block allocated properly */
     if (hMemBlock1 != NULL)
   /* lock block into memory */
   Rasta1 = (char NEAR *)LocalLock(hMemBlock1);

 /* ask for 4096 contiguous free bytes */
     ContigFreeBytes = (WORD)LocalCompact((WORD)4096);
     sprintf(szBuff,"Number of contiguous free bytes = %u",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After allocating 2 bytes...",MB_OK)

 /* Allocate 200 bytes from local heap */
     hMemBlock2 = LocalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE |GMEM_DISCARDABLE,
         (long)200);
 /* if memory allocated properly */
     if (hMemBlock2 != NULL)
   /* lock block into memory */
   Rasta2 = (char NEAR *)LocalLock(hMemBlock2);

 /* ask for 4096 contiguous free bytes */
     ContigFreeBytes = (WORD)LocalCompact((WORD)4096);
     sprintf(szBuff,"Number of contiguous free bytes = %u",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After allocating 200 bytes...",MB_O

     LocalUnlock(hMemBlock1);
     LocalUnlock(hMemBlock2);

     LocalFree(hMemBlock1);
     LocalFree(hMemBlock2);

 /* ask for FFFF contiguous free bytes */
     ContigFreeBytes = (WORD)LocalCompact((WORD)4096);

     sprintf(szBuff,"Number of contiguous free bytes = %u",ContigFreeBytes);
     MessageBox(NULL,(LPSTR)szBuff,(LPSTR)"After unlocking 200 bytes...",MB_OK

     return 0;
 }


 LOCLOCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCLOCK.C

 /*
  *  LocalLock
  *
  *  This program demonstrates the use of the function LocalLock.  It
  *  allocates a block of memory, using LocalAlloc, Locks it, copies a string
  *  into it and displays it in a message box.
  */

 #include <windows.h>

 int PASCAL WinMain ( hInstance , hPrevInstance, lpszCmdLine, cmdShow )

 HANDLE  hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;    /*  The memory block  */
   WORD    wFlags;     /*  Return Value from function  */
   char NEAR *  pBuffer;    /*  Pointer to locked buffer  */
   char *  strcpy();    /*  Tell compiler that it returns
            *  a pointer to a char
            */

   hMemBlock = LocalAlloc( LMEM_ZEROINIT | LMEM_MOVEABLE ,
        (WORD) 80 );

        /*  Allocate 80 bytes of moveable memory and initialize
   *  all of the bytes to 0
   */

   pBuffer = LocalLock ( hMemBlock );
        /*  Lock it and return the pointer  */

   if ( pBuffer != NULL )
     {
     strcpy ( pBuffer , "LocalLock was Successfull" );
     MessageBox( NULL , (LPSTR) pBuffer , (LPSTR) "OK" , MB_OK );
        /*  Display the message that all is OK  */
     }
   else
     MessageBox( NULL , (LPSTR)"LocalLock was not Successfull" ,
     (LPSTR)"OK" , MB_OK );

   return 0;
   }


 LOCREALL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCREALL.C

 /*
  *  LocalReAlloc
  *
  *  This program demonstrates the use of LocalReAlloc.  It will allocate
  *  a block of memory using LocalAlloc, copy a string to the block of
  *  memory, enlarge the block, and then display the string using the
  *  MessageBox function.
  */

 #include <windows.h>

 int PASCAL WinMain ( hInstance , hPrevInstance, lpszCmdLine, cmdShow )

 HANDLE  hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;    /*  The memory block  */
   HANDLE  hNewBlock;    /*  A handle to the new memory block  */
   WORD    wFlags;     /*  Return Value from function  */
   char NEAR *  pBuffer;    /*  Pointer to locked buffer  */
   char *  strcpy();    /*  Tell compiler that it returns
            *  a pointer to a char
            */

   hMemBlock = LocalAlloc( LMEM_ZEROINIT | LMEM_MOVEABLE ,
        (WORD) 70 );
        /*  Allocate 70 bytes of moveable memory and initialize
   *  all of the bytes to 0
   */

   pBuffer = LocalLock ( hMemBlock );
   if ( pBuffer != NULL )
     {
     strcpy ( pBuffer , "Both LocalReAlloc and LocalLock were Successfull" );
     LocalUnlock( hMemBlock );
        /*  Place string into pBuffer and unlock the memory.
   *  When increasing the size of the block, we don't have to worry
   *  about the contents.  They will still be intact, but there will
   *  be more memory available
   */
     }

   hNewBlock = LocalReAlloc( hMemBlock , 80 ,
           LMEM_MOVEABLE | LMEM_ZEROINIT );
        /*  Resized the block to 80 bytes.  It makes the new block moveable
   *  and also initializes any new bytes to zero
   */

   if ( hNewBlock != NULL )      /*  Check to see if successful  */
     {
     pBuffer = LocalLock ( hNewBlock );
        /*  Lock it and return the pointer  */

     if ( pBuffer != NULL )
       MessageBox( NULL , (LPSTR) pBuffer , (LPSTR) "OK" , MB_OK );
    /*  Display the message that all is OK  */
     else
       MessageBox( NULL ,
      (LPSTR)"LocalLock was not Successfull, but LocalReAlloc was",
      (LPSTR)"OK" , MB_OK );
    /*  Tell user that things went half right  */
     }
   else
     MessageBox( NULL , (LPSTR)"LocalReAlloc was not Successful" ,
     (LPSTR) "OK" , MB_OK );
   /*  Tell user that it didn't work at all  */

   return 0;
   }


 LOCSHRNK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCSHRNK.C

 /**************************************************************************
  *  LOCSHRNK  version 1.00
  *
  * This program tests the LocalShrink function, which shrinks the size of
  * the local heap and returns the current size. If the shrinksize is larger
  * than the current size, it will only return the current size.
  *
  * Using NULL for the first parameter will default to the current data
  * segment.
  *
  * compiled on IBM AT w640K EGA running WINDOWS 2.03
  **************************************************************************/

 #include <windows.h>
 #include <stdio.h>

 #define  MADMAX  45000
 #define  MAXHEAP  20480
 #define  HEAPSIZE  2048

 int PASCAL      WinMain(HANDLE,HANDLE,LPSTR,int);

 char  szPurpose[80] = "This is a program to initialize the local heap";

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
 {
     HANDLE   hMemBlock;
     char     MesBuf[250];
     DWORD     dwMemSize;

    MessageBox(GetFocus(),(LPSTR)szPurpose,(LPSTR)"LOCINIT",MB_OK);

   /* Get size of local heap by giving meaningless shrink value */
    dwMemSize = LocalShrink(NULL, MADMAX);

    sprintf(MesBuf,"%s%lu","Size of local heap: ",dwMemSize);
    MessageBox(GetFocus(),(LPSTR)MesBuf,(LPSTR)"LocolShrink",MB_OK);

   /* Increase the size of the local heap */
    hMemBlock = LocalAlloc(LMEM_ZEROINIT | LMEM_MOVEABLE,(WORD)MAXHEAP);

    /* Get new size */
    dwMemSize = LocalShrink(NULL, MADMAX);

    sprintf(MesBuf,"%s%lu","New size of local heap: ",dwMemSize);
    MessageBox(GetFocus(),(LPSTR)MesBuf,(LPSTR)"Shrink",MB_OK);

   LocalFree(hMemBlock);

    /* Shrink local heap down to original size */
    dwMemSize = LocalShrink(NULL, HEAPSIZE);

    sprintf(MesBuf,"Size of local heap after actually shrinking: %lu",
      dwMemSize);
    MessageBox(GetFocus(),(LPSTR)MesBuf,(LPSTR)"Shrink",MB_OK);

    MessageBox(GetFocus(),(LPSTR)"Initialized and Accessed Local Heap Succesfu
      (LPSTR)"LocalInit",MB_OK);

    return (0);
 } /* WINMAIN */




 LOCSIZE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOCSIZE.C

 /*
  *  LocalSize
  *
  *  This program demonstrates the use of the function LocalSize.  It
  *  allocates a block of memory, using LocalAlloc, Locks it, copies a string
  *  into it, displays it in a message box along with the size of the
  *  memory block.  (Which is returned by LocalSize)
  */

 #include <windows.h>

 int PASCAL WinMain ( hInstance , hPrevInstance, lpszCmdLine, cmdShow )

 HANDLE  hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;    /*  The memory block  */
   WORD    wFlags;     /*  Return Value from function  */
   char NEAR *  pBuffer;    /*  Pointer to locked buffer  */
   int           bytes;            /*  Number of bytes allocated  */

   hMemBlock = LocalAlloc( LMEM_ZEROINIT | LMEM_MOVEABLE ,
        (WORD) 80 );

        /*  Allocate 80 bytes of moveable memory and initialize
   *  all of the bytes to 0
   */

   bytes = LocalSize( hMemBlock );
                   /*  Find out the size of hMemBlock  */

   pBuffer = LocalLock ( hMemBlock );
        /*  Lock it and return the pointer  */

   if ( pBuffer != NULL )
     {
     sprintf( (char *) pBuffer , "LocalAlloc allocated %d bytes" , bytes );
     MessageBox( NULL , (LPSTR) pBuffer , (LPSTR) "OK" , MB_OK );
        /*  Display the message that all is OK  */
     }
   else
     MessageBox( NULL , (LPSTR)"LocalLock was not Successfull" ,
     (LPSTR)"OK" , MB_OK );

   return 0;
   }


 LOUNLOCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\LOCAL\LOUNLOCK.C

 /*
  *  LocalUnlock
  *
  *  This program demonstrates the use of the LocalUnlock function.  It
  *  will allocate a block of memory using LocalAlloc, lock the
  *  memory with LocalLock, copy a string to it and display it with
  *  the MessageBox function, and then unlock the memory block with the
  *  local Unlock function.
  */

 #include <windows.h>

 int PASCAL WinMain ( hInstance , hPrevInstance, lpszCmdLine, cmdShow )

 HANDLE  hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   HANDLE  hMemBlock;    /*  The memory block  */
   WORD    wFlags;     /*  Return Value from function  */
   char NEAR *  pBuffer;    /*  Pointer to locked buffer  */
   char *  strcpy();    /*  Tell compiler that it returns
            *  a pointer to a char
            */

   hMemBlock = LocalAlloc( LMEM_ZEROINIT | LMEM_MOVEABLE ,
        (WORD) 80 );

        /*  Allocate 80 bytes of moveable memory and initialize
   *  all of the bytes to 0
   */

   pBuffer = LocalLock ( hMemBlock );
        /*  Lock it and return the pointer to the locked block  */

   if ( pBuffer != NULL )  /*  Make sure that it was locked
          *  Returns NULL if it wasn't
          */
     {
     strcpy ( pBuffer , "LocalLock was Successfull" );
        /*  Place the string into the block  */

     MessageBox( NULL , (LPSTR) pBuffer , (LPSTR) "OK" , MB_OK );
        /*  Display the message that all is OK  */

     LocalUnlock( hMemBlock );
        /*  Unlock Memory Block  */
     }
   else
     MessageBox( NULL , (LPSTR)"LocalLock was not Successfull" ,
     (LPSTR)"ERROR!!!" , MB_OK );

   return 0;
   }


 LPTODP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\LPTODP.C

 /*
  *  Function Name:   CreatePolyRgn
  *  Program Name:    crpolyrg.c
  *
  *  SDK Version:         2.03
  *  Runtime Version:     2.03
  *  Microsoft C Version: 5.1
  *
  *  Description:
  *   The program below will set the map mode to MM_LOENGLISH, then
  *   assign a POINT data structure the logical coordinates for making
  *   a poloygon (triangle).  The POINT structure will then be converted
  *   to device coordinates and displayed in MM_TEXT (device
  *   coordinates) map mode.
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_LPtoDP(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   POINT Points[4];
   BOOL    bConverted;


   SetMapMode(hDC, MM_LOENGLISH);

   Points[0].x = 100;                        /* logical points */
   Points[0].y = -300;                     /* in MM_LOENGLISH mode */
   Points[1].x = 100;
   Points[1].y = -200;
   Points[2].x = 500;
   Points[2].y = -300;
   Points[3].x = 100;
   Points[3].y = -300;
                                           /* conversion to device points */
   bConverted = LPtoDP(hDC, (LPPOINT)Points, 4);

   if (bConverted == FALSE)                   /* Check for error */
     MessageBox(hWnd, (LPSTR)"LPtoDP failed.", (LPSTR)"ERROR", MB_ICONHAND);

   SetMapMode(hDC, MM_TEXT);    /* back to MM_TEXT - Points now in device  */
   Polyline (hDC, (LPPOINT)Points, 4);               /* coordinates.       */
   TextOut(hDC, 10, 10, (LPSTR)"Logical points converted in program", 35);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"LPtoDP";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"LPtoDP",
                         (LPSTR)"LPtoDP()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_LPtoDP(hWnd, ps.hdc);
         ValidateRect(hWnd, (LPRECT) NULL);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }



 MAKEPROC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\MAKEPROC.C

 /*
  *
  *  MakeProcInstance
  *
  *  This program demonstrates the use of the functions MakeProcInstance.
  *  MakeProcInstance binds the segment of the model instance to the
  *  function pointed to by lpProc.
  *
  *  Other references: DlgOpen.c, DlgSave.c, Print.c
  *
  */

 #include <windows.h>

 static char  szAppName[] = "makeproc";
 static char  szFuncName[] = "MakeProcInstance";
 HANDLE hInst;

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 long  FAR PASCAL TestFarFunc (HWND, unsigned, WORD, LONG);

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   HWND     hWnd;
   WNDCLASS rClass;
   MSG      msg;

   if (!hPrevInstance)
   {
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = NULL;
     rClass.lpszClassName = szAppName;

     if (!RegisterClass (&rClass))
       return FALSE;
   }

   hInst = hInstance;

 hWnd = CreateWindow (szAppName,            /* window class name       */
 szFuncName,                 /* window caption          */
 WS_OVERLAPPEDWINDOW,        /* window style            */
 CW_USEDEFAULT,              /* initial x position      */
 0,                          /* initial y position      */
 CW_USEDEFAULT,              /* initial x size          */
 0,                          /* initial y size          */
 NULL,                       /* parent window handle    */
 NULL,                       /* window menu handle      */
 hInstance,                  /* program instance handle */
   NULL);                      /* create parameters       */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage ((LPMSG) & msg);
     DispatchMessage ((LPMSG) & msg);
   }
   return (msg.wParam);
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   HMENU   hMenu;
   FARPROC lpProc;

   switch (iMessage)
   {
   case WM_CREATE:
     hMenu = CreateMenu ();
     ChangeMenu (hMenu, NULL, (LPSTR)"Make", 100, MF_APPEND);
     SetMenu (hWnd, hMenu);
     break;
   case WM_COMMAND:
     if (wParam == 100)
     {
       MessageBox (GetFocus(), (LPSTR)"Making instance proc.",
           (LPSTR)szFuncName, MB_OK);
       lpProc = MakeProcInstance ((FARPROC)TestFarFunc, hInst);
       if (lpProc != NULL)
   MessageBox (GetFocus(), (LPSTR)"Instance proc. made",
       (LPSTR)szFuncName, MB_OK);
       else
   MessageBox (GetFocus(), (LPSTR)"Instance proc. not made",
       (LPSTR)szFuncName, MB_OK);
       FreeProcInstance (lpProc);
     }
     break;
   case WM_DESTROY:
     PostQuitMessage (0);
     break;
   default:
     return (DefWindowProc (hWnd, iMessage, wParam, lParam));
   }
   return (0L);
 }


 long  FAR PASCAL TestFarFunc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned  iMessage;
 WORD     wParam;
 LONG     lParam;
 {
   return TRUE;
 }




 MAPDLGR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\MAPDLGR.C

 /*
  *  Function (s) demonstrated in this program: MapDialogRect
  *  Description:
  *     When the About dialog box is brought up, it has two buttons.  The OK
  *  button to end the dialog box, and the DRAW button which draws an
  *  ellipse in the upper left hand corner.  Coordinates for the ellipse
  *  are converted from dialog coordinates to screen coordinates using
  *  the MapDialogRect function.
  */

 #include "windows.h"
 #include "mapdlgr.h"

 HANDLE hInst;

 /**************************************************************************/

 int     PASCAL WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE    hInstance;
 HANDLE    hPrevInstance;
 LPSTR     lpCmdLine;
 int       nCmdShow;
   {
   HWND hWnd;
   MSG msg;
   WNDCLASS WndClass;

   WndClass.style = NULL;
   WndClass.lpfnWndProc = MapDlgRectWndProc;
   WndClass.hInstance = hInstance;
   WndClass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   WndClass.hCursor = LoadCursor (NULL, IDC_ARROW);
   WndClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   WndClass.lpszMenuName = (LPSTR) NULL;
   WndClass.lpszClassName = (LPSTR) "MapDlgRect";

   if (!RegisterClass ((PWNDCLASS)&WndClass))
     return FALSE;

   hInst = hInstance;

   hWnd = CreateWindow ("MapDlgRect", (LPSTR)"MapDlgRect Sample Application",
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, NULL, hInstance, NULL);
   if (!hWnd)
     return (NULL);

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

   while (GetMessage (&msg, NULL, NULL, NULL))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL MapDlgRectWndProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
   {
   FARPROC lpProcAbout;
   HMENU hMenu;

   switch (message)
     {
     case WM_SYSCOMMAND:           /* message: command from system menu */
       if (wParam == ID_ABOUT)
         {
         lpProcAbout = MakeProcInstance (About, hInst);
         DialogBox (hInst, "AboutBox", hWnd,        lpProcAbout);
         FreeProcInstance (lpProcAbout);
         break;
         }
       else
         return (DefWindowProc (hWnd, message, wParam, lParam));

     case WM_CREATE:
       hMenu = GetSystemMenu (hWnd, FALSE);
       ChangeMenu (hMenu, NULL, NULL, NULL, MF_APPEND | MF_SEPARATOR);
       ChangeMenu (hMenu, NULL, "A&bout MapDlgRect...", ID_ABOUT,
                   MF_APPEND | MF_STRING);
       break;

     case WM_DESTROY:                /* message: window being destroyed */
       PostQuitMessage (0);
       break;

     default:                        /* Passes it on if unproccessed    */
       return (DefWindowProc (hWnd, message, wParam, lParam));
     }
   return (NULL);
   }

 BOOL FAR PASCAL About (hDlg, message, wParam, lParam)
 HWND       hDlg;
 unsigned   message;
 WORD       wParam;
 LONG       lParam;
   {
   RECT      rRect;     /*  Rectangle to draw elipse onto Dialog box  */
   HDC       hDC;       /*  Handle to display context  */

   switch (message)
     {
     case WM_INITDIALOG:                /* message: initialize dialog box */
       return (TRUE);

     case WM_COMMAND:                    /* message: received a command */
       if (wParam == IDOK)
         {         /* "OK" box selected?          */
         EndDialog (hDlg, NULL);          /* Exits the dialog box        */
         return (TRUE);
         }
       if (wParam == ID_DRAW)  /*  If they hit the Draw button, draw
                                *  an ellipse in the dialog box  */
         {
         hDC = GetDC (hDlg);      /* get DC for the dialog box */
         rRect.left = 0;          /* These coordinates are in dialog
                                   * box units.  They will be converted
                                   * to screen coordinates by the
                                   * MapDialogRect function  */
         rRect.top = 0;
         rRect.right = 20;
         rRect.bottom = 10;
         MapDialogRect (hDlg, (LPRECT) & rRect);
         Ellipse (hDC, rRect.left, rRect.top, rRect.right, rRect.bottom);
         ReleaseDC (hDlg, hDC);
         return (TRUE);
         }
       break;
     }
   return (FALSE);
   }


 MAPMODE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\MAPMODE.C

 /*
  *  SetMapMode
  *
  *  This function demonstrates the use of the SetMapMode function.  It will
  *  create a window, and procede to draw a triangle in the window in
  *  the MM_ANISOTROPIC mapping mode.
  */

 #include <windows.h>

 BOOL FAR PASCAL InitSetMapMode (HANDLE, HANDLE, int);
 long    FAR PASCAL SetMapModeWindowProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
   {
   MSG  msg;

   InitSetMapMode (hInstance, hPrevInstance, cmdShow);   /*  Init Routine  */

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   exit (msg.wParam);
   }

 BOOL FAR PASCAL InitSetMapMode (hInstance, hPrevInstance, cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;
   {
   WNDCLASS  wcSetMapModeClass;
   HWND  hWnd;

   wcSetMapModeClass.lpszClassName = (LPSTR) "SetMapMode";
   wcSetMapModeClass.hInstance     = hInstance;
   wcSetMapModeClass.lpfnWndProc   = SetMapModeWindowProc;
   wcSetMapModeClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcSetMapModeClass.hIcon         = NULL;
   wcSetMapModeClass.lpszMenuName  = (LPSTR) NULL;
   wcSetMapModeClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcSetMapModeClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcSetMapModeClass.cbClsExtra    = 0;
   wcSetMapModeClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcSetMapModeClass);

   hWnd = CreateWindow ( (LPSTR) "SetMapMode", (LPSTR) "SetMapMode",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,    0,
                       CW_USEDEFAULT,    0,
                       NULL,     NULL,   hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }

 long    FAR PASCAL SetMapModeWindowProc (hWnd, message, wParam, lParam)

 HWND      hWnd;
 unsigned    message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_PAINT:
       PaintSetMapModeWindow (hWnd);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }

 PaintSetMapModeWindow (hWnd)
 HWND  hWnd;
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE        hOldBrush, hBrush;
   RECT    rRect;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
   hDC = ps.hdc;

   hBrush = GetStockObject (GRAY_BRUSH);
   hOldBrush = SelectObject (hDC, hBrush);

   lpTriangle[0].x = 150;
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode (hDC, MM_ANISOTROPIC);     /*  Set the mapping mode

   SetWindowExt (hDC, 300, 300);        /*  Set the extent of the drawing
                                         *  area.  This is the area that
                                         *  holds graphics that you create
                                         *  with GDI functions.  Do not
                                         *  confuse this function with
                                         *  the actual window.  The
                                         *  SetViewportExt sets the
                                         *  extent of the area to be mapped
                                         *  to which is the actual window
                                         */
   GetClientRect (hWnd, (LPRECT) & rRect);
 /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt (hDC, rRect.right, rRect.bottom);

   Polygon (hDC, lpTriangle, 3);

   ValidateRect (hWnd, (LPRECT) NULL);
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   SelectObject (hDC, hOldBrush);
   return TRUE;
   }


 MESSBEEP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\MESSBEEP.C

 /*
  *  MessageBeep
  *
  *  This program demonstrates the use of the MessageBeep function.
  *
  */

 #include <windows.h>

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   if (MessageBeep (MB_OK) == FALSE)
     MessageBox (NULL, (LPSTR)"MessageBeep Failed", (LPSTR)"ERROR!!!", MB_OK);
   return 0;
   }


 MESSBOX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\MESSBOX.C

 /*
  *  MessageBox
  *
  *  This program demonstrates the use of the MessageBox function.  It
  *  will display a simple message.
  */

 #include <windows.h>

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MessageBox (GetFocus(),  /*  Because we have no parent window we feed it
                             *  the current focus.
                             */
   (LPSTR) "This is a Message Box",   /*  The message  */
   (LPSTR) "OK",                      /*  Message Header  */
   MB_OK);                            /* Type of buttons      */
   return 0;
   }


 MOVETO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\MOVETO.C

 /*
  *  MoveTo
  *
  *  This program will demonstrate the use of the MoveTo function.  It will
  *  draw a triangle using MoveTo and LineTo.
  */

 #include <windows.h>

 BOOL FAR PASCAL InitMoveTo (HANDLE, HANDLE, int);
 long    FAR PASCAL MoveToWindowProc (HANDLE, unsigned, WORD, LONG);

 int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int      cmdShow;
   {
   MSG  msg;

   InitMoveTo (hInstance, hPrevInstance, cmdShow);  /*  Init Routine  */
   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     {
     TranslateMessage ( (LPMSG) & msg);
     DispatchMessage ( (LPMSG) & msg);
     }
   exit (msg.wParam);
   }

 BOOL FAR PASCAL InitMoveTo (hInstance, hPrevInstance, cmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 int      cmdShow;
   {
   WNDCLASS  wcMoveToClass;
   HWND      hWnd;

   wcMoveToClass.lpszClassName = (LPSTR) "MoveTo";
   wcMoveToClass.hInstance     = hInstance;
   wcMoveToClass.lpfnWndProc   = MoveToWindowProc;
   wcMoveToClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcMoveToClass.hIcon        = NULL;
   wcMoveToClass.lpszMenuName  = (LPSTR) NULL;
   wcMoveToClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcMoveToClass.style        = CS_HREDRAW | CS_VREDRAW;
   wcMoveToClass.cbClsExtra    = 0;
   wcMoveToClass.cbWndExtra    = 0;

   RegisterClass ( (LPWNDCLASS) & wcMoveToClass);

   hWnd = CreateWindow ( (LPSTR) "MoveTo", (LPSTR) "MoveTo",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,    0,
                       CW_USEDEFAULT,    0,
                       NULL,     NULL,   hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
   }

 long    FAR PASCAL MoveToWindowProc (hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned    message;
 WORD      wParam;
 LONG      lParam;
   {
   switch (message)
     {
     case WM_PAINT:
       PaintMoveToWindow (hWnd);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }

 PaintMoveToWindow (hWnd)
 HWND  hWnd;
   {
   int   cX1, cY1, cX2, cY2;
   int   xinc, yinc;

   PAINTSTRUCT  ps;
   HDC    hDC;
   RECT    rRect;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);  /* Prepare the client area */
   hDC = ps.hdc;            /*  Get the Display Context  */

   GetClientRect (hWnd, (LPRECT) & rRect);
 /*  Get the size of the client area  */

   cX1 = rRect.left;       /*  Get the left side of the client area  */
   cY1 = rRect.top;       /*  Get the top of the client area  */
   cX2 = rRect.right;       /*  Get the right side of the client area  */
   cY2 = rRect.bottom;       /*  Get the bottom of the client area  */

   xinc = (cX2 - cX1) / 25;   /*  Figure out how much to increment  */
   yinc = (cY2 - cY1) / 25;  /*  x and y, evenly  */

   while (cX1 < rRect.right)
     {
     MoveTo (hDC, cX1, rRect.top);
 /*  Move the pen to the desired location  */
     LineTo (hDC, rRect.right, cY1);
 /*  Draw the line to the other side of the client area  */
     MoveTo (hDC, cX2, rRect.bottom);
 /*  Move the pen to the desired location  */
     LineTo (hDC, rRect.left, cY2);
 /*  Draw the line to the other side of the client area  */

     MoveTo (hDC, rRect.right, cY1);
 /*  Move the pen to the desired location  */
     LineTo (hDC, cX2, rRect.bottom);
 /*  Draw the line to the other side of the client area  */
     MoveTo (hDC, rRect.left, cY2);
 /*  Move the pen to the desired location  */
     LineTo (hDC, cX1, rRect.top);
 /*  Draw the line to the other side of the client area  */

     cX1 += xinc;
     cY1 += yinc;
     cX2 -= xinc;
     cY2 -= yinc;
     }
   ValidateRect (hWnd, (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   return TRUE;
   }


 MOVEWIND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\MOVEWIND.C

 /*
  *  MoveWindow
  *
  *  This function demonstrates the use of the MoveWindow function.  It will
  *  create a window, draw a pie slice in it, display a message box, and then
  *  move the window.
  */

 #include <windows.h>

 /* Forward Declarations  */

 BOOL FAR PASCAL InitPie ( HANDLE , HANDLE , int );
 long  FAR PASCAL PieWindowProc ( HANDLE , unsigned , WORD , LONG );

 /*
  *  MAIN PROCEDURE
  */

 int  PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , cmdShow )

 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;

   InitPie (hInstance, hPrevInstance, cmdShow );  /*  Init Routine  */

   while ( GetMessage((LPMSG) & msg, NULL, 0 , 0 ))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   exit(msg.wParam);
 }


 BOOL FAR PASCAL InitPie (hInstance , hPrevInstance , cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;

 {
   WNDCLASS  wcPieClass;
   HWND  hWnd;

   wcPieClass.lpszClassName = (LPSTR) "Pie";
   wcPieClass.hInstance     = hInstance;
   wcPieClass.lpfnWndProc   = PieWindowProc;
   wcPieClass.hCursor     = LoadCursor ( NULL , IDC_ARROW );
   wcPieClass.hIcon     = NULL;
   wcPieClass.lpszMenuName  = (LPSTR) NULL;
   wcPieClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPieClass.style     = CS_HREDRAW | CS_VREDRAW;
   wcPieClass.cbClsExtra    = 0;
   wcPieClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) & wcPieClass);

   hWnd = CreateWindow((LPSTR) "Pie", (LPSTR) "MoveWindow",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,   0,
       CW_USEDEFAULT,   0,
       NULL,   NULL,   hInstance, NULL);

   ShowWindow (hWnd , cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
 }


 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long  FAR PASCAL PieWindowProc (hWnd , message , wParam , lParam)

 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
 {
   static BOOL bFlag = FALSE;      /*  Tell us whether or not  */
 /*  we have moved the  */
 /*  Window      */

   switch (message)
   {
   case WM_PAINT:
     PaintPieWindow (hWnd);
     if ( bFlag == FALSE )
     {
       bFlag = TRUE;
       MessageBox( GetFocus() , (LPSTR)"Press the OK Button to move the window
           (LPSTR)"MOVE", MB_OK );

       MoveWindow( hWnd , 0 , 0 , 400 , 300 , TRUE );
 /*  Change the size as well as the position using the
          *  MoveWindow function.  We also tell the Window to
          *  re-paint the client area.  We use the bFlag variable
          *  to make sure we only call MoveWindow once.
          */
     }
     break;

   case WM_DESTROY:        /*  If close requested  */
     PostQuitMessage(0);      /*    send yourself a quit  */
     break;          /*    message    */

   default:
     return( DefWindowProc( hWnd , message , wParam , lParam ) );
     break;
   }
   return( 0L );
 }


 /*
  *  THE PAINT PROCEDURE
  */

 PaintPieWindow (hWnd)

 HWND  hWnd;          /*  Handle of the window  */
 {
   PAINTSTRUCT  ps;
   HDC    hDC;

   BeginPaint (hWnd , (LPPAINTSTRUCT) & ps);  /*  Prepare the client area */
   hDC = ps.hdc;            /*  Get the Display Context  */

   Pie ( hDC , 100 , 100 , 300 , 300 , 300 , 200 , 200 , 100 );
 /*  Draw the Pie
    *  Upper Left of box holding pie slice  = 100 , 100
    *  Lower Right of box holding pie slice = 300 , 300
    *  Start the arc at 300 , 300
    *  End the arc at 200 , 100
    *  The arc will be drawn in a counter clockwise direction
    */

   ValidateRect (hWnd , (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps );

   return TRUE;
 }


 MUZIC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\MUZIC.C

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {

   int     i, j, q;

   MessageBox( GetFocus(), (LPSTR)"orginal", (LPSTR)"Sound routine", MB_OK);

    OpenSound();
    q=SetVoiceQueueSize(1,192);
    for (i=0; i < 60 ; i++) {  /* change frequency */
       for (j=0; j < 6 ; j++) {  /* change duration */
          SetVoiceSound(q,(LONG)440+(i*2),j);
          StartSound();
          WaitSoundState(QUEUEEMPTY);
       }
    }
    CloseSound();

   MessageBox( GetFocus(), (LPSTR)"Excel macro", (LPSTR)"Sound from", MB_OK);
  /* excel music macro */
   OpenSound();
   SetVoiceAccent(1,(LONG)100,255,0,0);
   q=SetVoiceQueueSize(1,400);
   SetVoiceNote(q,45,16,0); /* G# */
   StartSound();
   WaitSoundState(QUEUEEMPTY);
   CloseSound();

   StopSound();
   return 0;
 }



 OFFCLIPR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\REGION\OFFCLIPR.C

 /*
  * Function (s) demonstrated in this program: OffsetClipRgn
  * Compiler version: C 5.1
  * Description: This program creates a rectangle region, gets it location,
  *              frames the region, offsets the region, displays what kind
  *              of region it is, get it new loction of the region, frames
  *              the new location, and displays the difference of the offset.
  */

 #include <windows.h>
 #include <stdio.h>
 #include "offclipr.h"

 static char  szFuncName[] = "OffsetClipRgn";
 static char  szAppName[] = "OFFCLIPR";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        nCmdShow;
   {
   HWND        hWnd;
   WNDCLASS    wndclass;
   MSG         msg;
   HMENU       hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = (LPSTR)"OFFCLIP";
     wndclass.lpszClassName = szFuncName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hMenu = LoadMenu (hInstance, (LPSTR)"OFFCLIP");

   hWnd = CreateWindow (szFuncName, szAppName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, 0,
                       CW_USEDEFAULT, 0,
                       NULL, hMenu, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC         hDC;
   HRGN        hRgnBox;
   HBRUSH      hBlueBrush;
   HBRUSH      hRedBrush;
   RECT        rectBefore;
   RECT        rectAfter;
   short  nRgnType;
   int  nIndex;
   char  szBuffer [300];

   switch (iMessage)
     {
     case WM_INITMENU:
       InvalidateRect (hWnd, (LPRECT)NULL, TRUE);
       break;

     case WM_COMMAND:
       if (wParam == IDM_BOX)
         {
         hRgnBox = CreateRectRgn (50, 75, 125, 150);

         hBlueBrush = CreateSolidBrush (RGB (0, 0, 255));
         hRedBrush = CreateSolidBrush (RGB (255, 0, 0));
         if (hBlueBrush == NULL || hRedBrush == NULL)
           {
           MessageBox (GetFocus (), (LPSTR)"Error in Creating brushes.",
               (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
           return (0L);
           }

         hDC = GetDC (hWnd);

         nRgnType = SelectClipRgn (hDC, hRgnBox);
         if (nRgnType == ERROR)
           {
           MessageBox (GetFocus (), (LPSTR)"Error in selecting clip region.",
               (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
           return (0L);
           }

         nRgnType = GetClipBox (hDC, (LPRECT) & rectBefore);
         if (nRgnType == ERROR)
           {
           MessageBox (GetFocus (), (LPSTR)"Error in getting clip box.",
               (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
           return (0L);
           }
         FrameRect (hDC, (LPRECT) & rectBefore, hBlueBrush);

         MessageBox (GetFocus (), (LPSTR)"Going to offset clip region.",
             (LPSTR)szFuncName, MB_OK);

         nRgnType = OffsetClipRgn (hDC, 200, 50);
         switch (nRgnType)
           {
           case COMPLEXREGION:
             MessageBox (GetFocus (), (LPSTR)"Offset clip region is complex.",
                 (LPSTR)szFuncName, MB_OK);
             break;
           case SIMPLEREGION:
             MessageBox (GetFocus (), (LPSTR)"Offset clip region is simple.",
                 (LPSTR)szFuncName, MB_OK);
             break;
           case NULLREGION:
             MessageBox (GetFocus (), (LPSTR)"There is no offset clip region."
                 (LPSTR)szFuncName, MB_OK);
             break;
           case ERROR:
             MessageBox (GetFocus (), (LPSTR)"Error in offset clip region.",
                 (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
             break;
           default :
             MessageBox (GetFocus (), (LPSTR)"Error !!!!",
                 (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
             break;
           }

         nRgnType = GetClipBox (hDC, (LPRECT) & rectAfter);
         if (nRgnType == ERROR)
           {
           MessageBox (GetFocus (), (LPSTR)"Error in getting clip box.",
               (LPSTR)szFuncName, MB_OK | MB_ICONHAND);
           return (0L);
           }
         FrameRect (hDC, (LPRECT) & rectAfter, hRedBrush);

         nIndex = sprintf (szBuffer,
             "%s %d %s %d\n%s %d %s %d\n%s %d %s %d\n%s %d %s %d",
             "clip box .left moved from", rectBefore.left,
             "to", rectAfter.left,
             "clip box .right moved from", rectBefore.right,
             "to", rectAfter.right,
             "clip box .top moved from", rectBefore.top,
             "to", rectAfter.top,
             "clip box .bottom moved from", rectBefore.bottom,
             "to", rectAfter.bottom);
         MessageBox (GetFocus (), (LPSTR)szBuffer, (LPSTR)szFuncName, MB_OK);

         ReleaseDC (hWnd, hDC);  /*  Clean up Memory  */
         DeleteObject (hRgnBox);
         DeleteObject (hRedBrush);
         DeleteObject (hBlueBrush);
         }
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }


 OFFSETRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\OFFSETRG.C

 /*
  * Function (s) demonstrated in this program: OffsetRgn,
  *           BeginPaint, CreateRectRgn, EndPaint, GetSystemMetrics,
  *           InvalidateRect, SelectObject, TextOut, PostQuitMessage
  *
  * This program demonstrates the use of the Windows function OffsetRgn.
  * A handle to a rectangular region is generated by CreateRectRgn.  The
  * contents of this region are filled with a solid backround.  The
  * rectangle is initially located on one side of the client area.  When
  * a button is pressed then the client area is erased and the rectangle
  * is placed on the other side of the client area by the offsetrgn
  * function.  This process can be repeated indefinitely.
  *
  */

 #include <windows.h>
 #include <string.h>

 #define LEFT    0
 #define RIGHT   1

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 void WndPaint (HWND hWnd, HDC hDC, BOOL fPosition);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        nCmdShow;
   {
   static char  szAppName [] = "OffsetRgn";
   HWND          hWnd;
   WNDCLASS      wndclass;
   MSG           msg;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow (szAppName, (LPSTR) "OffsetRgn",
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, NULL, hInstance, NULL);

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

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }


 long    FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC      hDC;                 /* For the paint routine */
   PAINTSTRUCT ps;
   RECT     Rect;
   POINT    Point;
   static BOOL fPosition = LEFT; /* The value determines the location of the
                                  * rectangular region.  When LEFT then the
                                  * the region is located toward the top of
                                  * the window.  Otherwise the region is
                                  * located toward the bottom of the window.
                                  */
   switch (iMessage)
     {
     case WM_PAINT:
       hDC = BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
       WndPaint (hWnd, hDC, fPosition);
       EndPaint (hWnd, (LPPAINTSTRUCT) & ps);
       break;

     case WM_KEYUP:
       if (fPosition == LEFT)
         fPosition = RIGHT;
       else
         fPosition = LEFT;

       GetWindowRect (hWnd, &Rect);

       /* Translate screen coordinates to client coordinates for the *
        * InvalidateRect function.                                   */
       Point.x = Rect.left;
       Point.y = Rect.top;
       ScreenToClient (hWnd, &Point);  /* Translate the upper left hand corner
       Rect.left = Point.x;
       Rect.top = Point.y;

       Point.x = Rect.right;
       Point.y = Rect.bottom;
       ScreenToClient (hWnd, &Point); /* Translate the upper right hand corner
       Rect.right = Point.x;
       Rect.bottom = Point.y;

       InvalidateRect (hWnd, &Rect, TRUE);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
     }
   return (0L);
   }

 void WndPaint (hWnd, hDC, fPosition)
 HWND hWnd;
 HDC  hDC;
 BOOL fPosition;
   {
   HRGN        hRgn;
   short X, Y;

   TextOut (hDC, 10, 10, "Pressing any key will cause the OffsetRgn function",
   TextOut (hDC, 10, 22, "to change the position of the rectangular region.",
   SelectObject (hDC, GetStockObject (GRAY_BRUSH));

   X = GetSystemMetrics (SM_CXSCREEN);
   Y = GetSystemMetrics (SM_CYSCREEN);

   hRgn = CreateRectRgn (X / 4, Y / 4 + 50, X / 2, Y / 2 + 50);

   if (fPosition == LEFT)
 /* OffsetRgn moves the region identified by hRgn by the specified  *
      * offsets.  The function moves the region 150 units along the     *
      * x-axis and 0 units along the y-axis.                            */
     OffsetRgn (hRgn, 150, 0);          /* Move rectangle region to the right

   else
     OffsetRgn (hRgn, -150, 0);          /* Move rectangle region to the left

 /* PaintRgn fills the region specified by hRgn with the brush selected *
    * into the display context.                                           */

   PaintRgn (hDC, hRgn);
   DeleteObject (hRgn);     /*  Delete region from memory  */
   return;
   }


 OPENCOMM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\OPENCOMM.C

 /*
  *  OpenComm
  *
  *  This program demonstrates the use of the function OpenComm.
  *  It opens a communication device and assign a handle to it. The
  *  communication device is initialized to a default configuration.
  *  Spaces are allocated for the "recieve" and "transmit" queues.
  *  The communication port must be close before it can be open again with
  *  OpenComm.
  *
  */

 #include "windows.h"

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   short  nCid;            /* short integer identifying the opened
                           * communication device  */

   nCid = OpenComm ( (LPSTR)"COM1", 20, 20);

   if (nCid >= 0)
     MessageBox (GetFocus (), (LPSTR)"Com port opened!!", (LPSTR)"OK", MB_OK);
   else
     {
     MessageBox (GetFocus (), (LPSTR)"Com port not opened!!",
                (LPSTR)"FAIL!", MB_OK);
     return 0;
     }

   CloseComm (nCid);

   return 0;
   }


 OPENFILE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\OPENFILE.C

 /*   This program demonstrates the use of the function OpenFile
  *   This function creates, opens, reopens or deletes a file.  In
  *   this program, "OpenFile.txt" will be opened, and the contents
  *   displayed in a MessageBox.
  */

 #include "string.h"
 #include <windows.h>

  Buf_Size 12                /* Buffer size to read with */
  Name_Size 13               /* Max length for name of external file */

 int     read (int, char *, int);
 int     close (int);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HANDLE hMem;

   OFSTRUCT ReOpenBuff;
   int   errchk;
   int   hFile;
   char  *szBuf;

 /***************************************************************************/

   MessageBox (NULL, (LPSTR)"About to open and read OPENFILE.TXT.",
       (LPSTR)"Ready", MB_OK);

   hFile = OpenFile ( (LPSTR)"openfile.txt",   /* Open file.          */
   (LPOFSTRUCT) & ReOpenBuff, OF_READ);
   if (hFile == -1)
     {                                      /* If not successful, say so.  */
     MessageBox (NULL,
         (LPSTR) "Problem opening file - OpenFile.txt",
         (LPSTR) "Error",
         MB_OK);
     }
   else
     {
     hMem = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, Buf_Size);
     szBuf = LocalLock (hMem);
     errchk = read (hFile, szBuf, Buf_Size - 1);
     szBuf[Buf_Size - 1] = '\0';

     if (errchk == -1)
       {                     /* If problem while reading,   */
                             /* say so.                     */
       MessageBox (NULL, (LPSTR) "Problem reading file.",
           (LPSTR) "ERROR", MB_OK);
       }
     errchk = close (hFile);
     if (errchk != -1)
       {                             /* If no error, print message box */
                                     /* with file contents.            */
       MessageBox (NULL, (LPSTR) szBuf, (LPSTR) "Success", MB_OK);
       }
     else
       {                             /* Error closing file.           */
       MessageBox (NULL, (LPSTR) "File not closed", (LPSTR) "ERROR", MB_OK);
       }
     }
   LocalUnlock (hMem);
   LocalFree (hMem);
   return TRUE;
   }


 OPENFILE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\OPENFILE.C

 /*   This program demonstrates the use of the function OpenFile
  *   This function creates, opens, reopens or deletes a file.  In
  *   this program, "OpenFile.txt" will be opened, and the contents
  *   displayed in a MessageBox.
  */

 #include "string.h"
 #include <windows.h>

  Buf_Size 12                /* Buffer size to read with */
  Name_Size 13               /* Max length for name of external file */

 int     read (int, char *, int);
 int     close (int);

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HANDLE hMem;

   OFSTRUCT ReOpenBuff;
   int   errchk;
   int   hFile;
   char  *szBuf;

 /***************************************************************************/

   MessageBox (NULL, (LPSTR)"About to open and read OPENFILE.TXT.",
       (LPSTR)"Ready", MB_OK);

   hFile = OpenFile ( (LPSTR)"openfile.txt",   /* Open file.          */
   (LPOFSTRUCT) & ReOpenBuff, OF_READ);
   if (hFile == -1)
     {                                      /* If not successful, say so.  */
     MessageBox (NULL,
         (LPSTR) "Problem opening file - OpenFile.txt",
         (LPSTR) "Error",
         MB_OK);
     }
   else
     {
     hMem = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, Buf_Size);
     szBuf = LocalLock (hMem);
     errchk = read (hFile, szBuf, Buf_Size - 1);
     szBuf[Buf_Size - 1] = '\0';

     if (errchk == -1)
       {                     /* If problem while reading,   */
                             /* say so.                     */
       MessageBox (NULL, (LPSTR) "Problem reading file.",
           (LPSTR) "ERROR", MB_OK);
       }
     errchk = close (hFile);
     if (errchk != -1)
       {                             /* If no error, print message box */
                                     /* with file contents.            */
       MessageBox (NULL, (LPSTR) szBuf, (LPSTR) "Success", MB_OK);
       }
     else
       {                             /* Error closing file.           */
       MessageBox (NULL, (LPSTR) "File not closed", (LPSTR) "ERROR", MB_OK);
       }
     }
   LocalUnlock (hMem);
   LocalFree (hMem);
   return TRUE;
   }


 OPENICON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ICON\OPENICON.C

 /*
  * Function (s) demonstrated in this program: OpenIcon
  *
  * Description:
  * This sample program demonstrates how to use the OpenIcon Windows
  * function.  Two windows are created.  The first window is initially
  * displayed as an open window.  The second window is initially
  * displayed as an iconized window.  After both windows are created and
  * displayed then a message box prompts the user to press return.  Upon
  * receiving <RETURN>, The message box closes.  This is followed by a
  * call to the function OpenIcon which opens the iconized window.
  *
  */

 #include <windows.h>
 #include <string.h>
 #include "openicon.h"

 long    FAR PASCAL WndProc1 (HWND, unsigned, WORD, LONG);
 long    FAR PASCAL WndProc2 (HWND, unsigned, WORD, LONG);

 static char     szAppName1 [] = "OpenIcon, window number 1";
 static char     szAppName2 [] = "OpenIcon, window number 2";
 static char  szResName [] = "ResMenu";
 static HWND hWnd1, hWnd2;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int  nCmdShow;
   {
   WNDCLASS wndclass;
   MSG      msg;
   HDC      hDC;
   HMENU    hMenu;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc1;
     wndclass.cbClsExtra    = 0;
     wndclass.cbWndExtra    = 0;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName  = NULL;
     wndclass.lpszClassName = szAppName1;

     if (!RegisterClass (&wndclass))
       return FALSE;

     wndclass.lpfnWndProc   = WndProc2;
     wndclass.lpszClassName = szAppName2;

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hMenu = LoadMenu (hInstance, "ResMenu");

   hWnd1 = CreateWindow (szAppName1, szAppName1,
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, hMenu, hInstance, NULL);

   ShowWindow (hWnd1, nCmdShow);
   UpdateWindow (hWnd1);

   hWnd2 = CreateWindow (szAppName2, szAppName2,
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0,
                        NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd2, SW_MINIMIZE);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return (msg.wParam);
   }

 long    FAR PASCAL WndProc1 (hWnd1, iMessage, wParam, lParam)
 HWND     hWnd1;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   switch (iMessage)
     {
     case WM_COMMAND:
       if (wParam == IDM_EXECUTE)
         OpenIcon (hWnd2);                /* Open the iconized window */
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd1, iMessage, wParam, lParam);
     }
   return (0L);
   }

 long    FAR PASCAL WndProc2 (hWnd2, iMessage, wParam, lParam)
 HWND     hWnd2;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
   {
   HDC hDC;
   PAINTSTRUCT ps;

   switch (iMessage)
     {
     case WM_PAINT:
       hDC = BeginPaint (hWnd2, &ps);
       TextOut (hDC, 30, 30,
           (LPSTR)"This window was opened by the OpenIcon function", 47);
       EndPaint (hWnd2, &ps);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd2, iMessage, wParam, lParam);
     }
   return (0L);
   }


 OPENSND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\OPENSND.C

 /*
  *  OpenSound
  *
  *  This program demonstrates the use of the function OpenSound.
  *  This function opens access to the play device ande prevents subsequent
  *  opening of the device by other applications.  This function has no
  *  parameters.
  *
  */

 #include "windows.h"

 int  sprintf (PSTR, PSTR, int);

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   short  nVoices;
   char  szBuffer[30];

   nVoices = OpenSound ();   /* Opens access to the play device and prevents
                              * subsequent opening of the device by other
                              * applications.  Return value specifies the
                                    * number of voices available. */

   CloseSound ();  /* CloseSound must be invoked to allow other applications
                         * to access the play device */

 /* return code for OpenSound routine */
   if (nVoices == S_SERDVNA)
   {
     MessageBox (NULL, (LPSTR)"Play device in use",
         (LPSTR)"Done", MB_OK);
   }
   else if (nVoices == S_SEROFM)
   {
     MessageBox (NULL, (LPSTR)"Insufficient memory available",
         (LPSTR)"Done", MB_OK);
   }
   else
   {
     sprintf (szBuffer, "%d voice (s) are available", nVoices);
     MessageBox (GetFocus (), (LPSTR)szBuffer,
         (LPSTR)"Done", MB_OK);
   }
   return 0;
 }




 PAINTRGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\PAINTRGN.C

 /*

 A handle to a display context is generated using the BeginPaint function.
 This handle is used to select a new brush into the current display context.
 Once this new brush is created, it is used to paint a grey backround within
 a rectangle.

 */

 #include <windows.h>
 #include <string.h>

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int  nCmdShow ;
 {
   static char  szAppName [] = "PaintRgn" ;
   HWND        hWnd ;
   WNDCLASS    wndclass ;
   MSG msg;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = NULL ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
       return FALSE ;
   }

   hWnd = CreateWindow (szAppName, (LPSTR)"PaintRgn",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   HDC      hDC;
   HRGN     hRgn;
   short  xX,                                      /* X coordinate */
   yY;                                      /* Y coordinate */

   PAINTSTRUCT ps;
   switch (iMessage)
   {
   case WM_PAINT:
     {
       hDC = BeginPaint(hWnd, (LPPAINTSTRUCT) & ps);

       TextOut (hDC, 10, 10,
           (LPSTR)"The Windows function PaintRgn is used to fill the backround
           strlen("The Windows function PaintRgn is used to fill the backround
           );

       TextOut (hDC, 10, 22,
           (LPSTR)"with the selected grey brush.",
           strlen("with the selected grey brush.")
           );


       SelectObject (hDC, GetStockObject (GRAY_BRUSH));

       xX = GetSystemMetrics (SM_CXSCREEN);
       yY = GetSystemMetrics (SM_CYSCREEN);

       hRgn = CreateRectRgn (xX / 4, yY / 4, xX / 2, yY / 2);
 /* PaintRgn fills the region specified by hRgn with the brush selected *
     * into the display context.
     */
       PaintRgn (hDC, hRgn);
       EndPaint(hWnd, (LPPAINTSTRUCT) & ps);
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
   }
   return (0L);
 }




 PEEKMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\PEEKMSG.C

 /*
  *  PeekMessage
  *
  *  This program will demonstrate the use of PeekMessage by catching all
  *  of the WM_PAINT messages and beeping, using MessageBeep, when there
  *  is one in the queue.
  *
  */

 #include "windows.h"
 #include "peekmsg.h"

 HANDLE hInst;

 int  PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int  nCmdShow;
 {
   BOOL bStatus;
   HWND hWnd;
   MSG msg;

   if (!hPrevInstance)
     if (!PeekMessageInit(hInstance))
       return (NULL);

   hInst = hInstance;   /* Saves the current instance      */

   hWnd = CreateWindow((LPSTR)"PeekMessage", (LPSTR)"PeekMessage Sample Applic
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL,  NULL,  hInstance, NULL);

   if (!hWnd)
     return (NULL);

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

   while (GetMessage(&msg, NULL, NULL, NULL))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     bStatus = PeekMessage(&msg,   /*  Message Structure  */
                           hWnd,   /*  Handle of window receiving the message
                           WM_PAINT,  /*  Lowest Message to examine  */
                           WM_PAINT,  /*  Highest Message to examine  */
                           PM_NOREMOVE);  /*  Don't remove the message  */

 /*  To get a WM_PAINT message to be sent, size the window in different ways.
  *  Using the Diagonal sizing seems to give the best results  */

     if (bStatus)
       MessageBeep(MB_OK);  /*  We got a message, beep!!!  */
   }
   return (msg.wParam);    /* Returns the value from PostQuitMessage */
 }


 BOOL PeekMessageInit(hInstance)
 HANDLE hInstance;
 {
   HANDLE hMemory;          /* handle to allocated memory */
   PWNDCLASS pWndClass;
   BOOL bSuccess;          /* RegisterClass() result     */

   hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
   pWndClass = (PWNDCLASS) LocalLock(hMemory);

   pWndClass->style = NULL;
   pWndClass->lpfnWndProc = PeekMessageWndProc;
   pWndClass->hInstance = hInstance;
   pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
   pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
   pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
   pWndClass->lpszMenuName = (LPSTR) NULL;
   pWndClass->lpszClassName = (LPSTR) "PeekMessage";

   bSuccess = RegisterClass(pWndClass);

   LocalUnlock(hMemory);       /* Unlocks the memory    */
   LocalFree(hMemory);        /* Returns it to Windows */

   return (bSuccess);   /* Returns result of registering the window */
 }


 long  FAR PASCAL PeekMessageWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   FARPROC lpProcAbout;
   HMENU hMenu;

   switch (message)
   {
   case WM_SYSCOMMAND:
     if (wParam == ID_ABOUT)
     {
       lpProcAbout = MakeProcInstance(About, hInst);

       DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);

       FreeProcInstance(lpProcAbout);
       break;
     }

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

   case WM_CREATE:

     hMenu = GetSystemMenu(hWnd, FALSE);

 /* Add a separator to the menu */

     ChangeMenu(hMenu, NULL, NULL, NULL, MF_APPEND | MF_SEPARATOR);

 /* Add new menu item to the System menu */

     ChangeMenu(hMenu, NULL, "A&bout PeekMessage...", ID_ABOUT,
         MF_APPEND | MF_STRING);
     break;

   case WM_DESTROY:    /* message: window being destroyed */
     PostQuitMessage(0);
     break;

   default:
     return (DefWindowProc(hWnd, message, wParam, lParam));
   }
   return (0L);
 }


 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_INITDIALOG:     /* message: initialize dialog box */
     return (TRUE);

   case WM_COMMAND:
     if (wParam == IDOK)
     {
       EndDialog(hDlg, NULL);
       return (TRUE);
     }
     break;
   }
   return (FALSE);
 }




 PIE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\PIE.C

 /*
  *  Pie
  *
  *  This function demonstrates the use of the Pie function.  It will create
  *  a window, and procede to draw a pie inside of that window
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitPie (HANDLE, HANDLE, int);
 long  FAR PASCAL PieWindowProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;
   InitPie (hInstance, hPrevInstance, cmdShow);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   exit(msg.wParam);
 }


 BOOL FAR PASCAL InitPie (hInstance, hPrevInstance, cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;

 {
   WNDCLASS  wcPieClass;
   HWND hWnd;

   wcPieClass.lpszClassName = (LPSTR) "Pie";
   wcPieClass.hInstance    = hInstance;
   wcPieClass.lpfnWndProc   = PieWindowProc;
   wcPieClass.hCursor    = LoadCursor (NULL, IDC_ARROW);
   wcPieClass.hIcon    = NULL;
   wcPieClass.lpszMenuName  = (LPSTR) NULL;
   wcPieClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPieClass.style    = CS_HREDRAW | CS_VREDRAW;
   wcPieClass.cbClsExtra    = 0;
   wcPieClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) & wcPieClass);

   hWnd = CreateWindow((LPSTR) "Pie", (LPSTR) "Pie",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL,  NULL,  hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
 }


 long  FAR PASCAL PieWindowProc (hWnd, message, wParam, lParam)

 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintPieWindow (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return(DefWindowProc(hWnd, message, wParam, lParam));
     break;
   }
   return(0L);
 }


 PaintPieWindow (hWnd)

 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC  hDC;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
   hDC = ps.hdc;

   Pie (hDC, 100, 100, 300, 300, 300, 200, 200, 100);
 /*  Draw the Pie
   *  Upper Left of box holding pie slice  = 100, 100
   *  Lower Right of box holding pie slice = 300, 300
   *  Start the arc at 300, 300
   *  End the arc at 200, 100
   *  The arc will be drawn in a counter clockwise direction
   */

   ValidateRect (hWnd, (LPRECT) NULL);
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   return TRUE;
 }




 PMETAFIL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\PMETAFIL.C

 /*
  *
  *  This program demonstrates the use of the function PlayMetaFile.
  *  This function plays the contents of the specified metafile on the
  *  given context.
  *
  */

 #include <windows.h>
 #include "pmetafil.h"

 static HANDLE hWnd;
 static char  szResName [] = "ResMenu";
 static char  szFileName[] = "pmetafil";
 static char  szFuncName[] = "PlayMetaFile";

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   MSG msg;
   if (!hPrevInstance)
   {
     WNDCLASS rClass;

     rClass.lpszClassName = (LPSTR)szFileName;
     rClass.hInstance     = hInstance;
     rClass.lpfnWndProc   = WndProc;
     rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon(hInstance, IDI_APPLICATION);
     rClass.lpszMenuName  = NULL;
     rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;

     RegisterClass((LPWNDCLASS) & rClass);
   }

   hWnd = CreateWindow((LPSTR)szFileName, (LPSTR)szFuncName,
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow(hWnd, cmdShow);
   UpdateWindow (hWnd) ;

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   static HANDLE hInstance;
   HMENU hMenu;
   HDC hDC;
   HANDLE hMF;
   BOOL bPlayed;
   switch (iMessage)
   {
   case WM_CREATE:
     {
       hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
       hMenu = LoadMenu(hInstance, "ResMenu");
       SetMenu(hWnd, hMenu);
       DrawMenuBar(hWnd);
       break;
     }
   case WM_COMMAND:
     {
       switch (wParam)
       {
       case IDM_EXECUTE:
   {
     hDC = GetDC(hWnd);
     hMF = GetMetaFile((LPSTR)"PMETAFIL.MET");

     MessageBox(GetFocus(), (LPSTR)"About To Play Metafile",
         (LPSTR)szFuncName, MB_OK);

     bPlayed = PlayMetaFile(hDC, hMF);

     if (bPlayed != 0)
       MessageBox(GetFocus(),
           (LPSTR)"Metafile Played Successfully (Rectangle Generated)",
           (LPSTR)szFuncName, MB_OK);
     else
       MessageBox (GetFocus(), (LPSTR)"Metafile Play Error", (LPSTR)szFuncName
           MB_OK);

     ReleaseDC(hWnd, hDC);
   }
       }
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
   }
   return (0L);
 }




 POLYGON.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\POLYGON.C

 /*
  *  Polygon
  *
  *  This function demonstrates the use of the Polygon function.  It will
  *  create a window, and procede to draw a triangle in the window.
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitPolygon (HANDLE, HANDLE, int);
 long  FAR PASCAL PolygonWindowProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;

   InitPolygon (hInstance, hPrevInstance, cmdShow);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   exit(msg.wParam);
 }


 BOOL FAR PASCAL InitPolygon (hInstance, hPrevInstance, cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;

 {
   WNDCLASS  wcPolygonClass;
   HWND hWnd;

   wcPolygonClass.lpszClassName = (LPSTR) "Polygon";
   wcPolygonClass.hInstance     = hInstance;
   wcPolygonClass.lpfnWndProc   = PolygonWindowProc;
   wcPolygonClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcPolygonClass.hIcon        = NULL;
   wcPolygonClass.lpszMenuName  = (LPSTR) NULL;
   wcPolygonClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPolygonClass.style        = CS_HREDRAW | CS_VREDRAW;
   wcPolygonClass.cbClsExtra    = 0;
   wcPolygonClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) & wcPolygonClass);

   hWnd = CreateWindow((LPSTR)"Polygon", (LPSTR) "Polygon",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL,  NULL,  hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
 }


 long  FAR PASCAL PolygonWindowProc (hWnd, message, wParam, lParam)

 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintPolygonWindow (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return(DefWindowProc(hWnd, message, wParam, lParam));
     break;
   }
   return(0L);
 }


 PaintPolygonWindow (hWnd)

 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC  hDC;
   POINT  lpTriangle[4];
   HANDLE hOldBrush, hBrush;


   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
   hDC = ps.hdc;

   hBrush = GetStockObject (GRAY_BRUSH);
   hOldBrush = SelectObject (hDC, hBrush);

   lpTriangle[0].x = 150;    /* The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   Polygon (hDC, lpTriangle, 3);  /*  Draw the triangle */

   ValidateRect (hWnd, (LPRECT) NULL);
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   SelectObject(hDC, hOldBrush);
   return TRUE;
 }




 POLYLINE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\POLYLINE.C

 /*
  *  Polyline
  *
  *  This function demonstrates the use of the Polyline function.  It will
  *  create a window, and procede to draw a small 3-D Box in the window.
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitPolyline (HANDLE, HANDLE, int);
 long  FAR PASCAL PolylineWindowProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   MSG  msg;

   InitPolyline (hInstance, hPrevInstance, cmdShow);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   exit(msg.wParam);
 }


 BOOL FAR PASCAL InitPolyline (hInstance, hPrevInstance, cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  cmdShow;

 {
   WNDCLASS  wcPolylineClass;
   HWND hWnd;

   wcPolylineClass.lpszClassName = (LPSTR) "Polyline";
   wcPolylineClass.hInstance     = hInstance;
   wcPolylineClass.lpfnWndProc   = PolylineWindowProc;
   wcPolylineClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcPolylineClass.hIcon         = NULL;
   wcPolylineClass.lpszMenuName  = (LPSTR) NULL;
   wcPolylineClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPolylineClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcPolylineClass.cbClsExtra    = 0;
   wcPolylineClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) & wcPolylineClass);

   hWnd = CreateWindow((LPSTR) "Polyline", (LPSTR) "Polyline",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL,  NULL,  hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   return TRUE;
 }


 long  FAR PASCAL PolylineWindowProc (hWnd, message, wParam, lParam)

 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintPolylineWindow (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return(DefWindowProc(hWnd, message, wParam, lParam));
     break;
   }
   return(0L);
 }


 PaintPolylineWindow (hWnd)

 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC  hDC;
   POINT       lpSide1[4];
   POINT       lpSide2[4];
   POINT       lpSide3[4];
   POINT       lpSide4[4];

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
   hDC = ps.hdc;

   lpSide1[0].x = 140;  /*  The values of the box  */
   lpSide1[0].y = 130;
   lpSide1[1].x = 100;
   lpSide1[1].y = 100;
   lpSide1[2].x = 170;
   lpSide1[2].y = 100;
   lpSide1[3].x = 200;
   lpSide1[3].y = 130;
   lpSide2[0].x = 100;
   lpSide2[0].y = 100;
   lpSide2[1].x = 100;
   lpSide2[1].y = 170;
   lpSide2[2].x = 170;
   lpSide2[2].y = 170;
   lpSide2[3].x = 170;
   lpSide2[3].y = 100;
   lpSide3[0].x = 100;
   lpSide3[0].y = 170;
   lpSide3[1].x = 140;
   lpSide3[1].y = 200;
   lpSide3[2].x = 200;
   lpSide3[2].y = 200;
   lpSide3[3].x = 170;
   lpSide3[3].y = 170;
   lpSide4[0].x = 140;
   lpSide4[0].y = 200;
   lpSide4[1].x = 140;
   lpSide4[1].y = 130;
   lpSide4[2].x = 200;
   lpSide4[2].y = 130;
   lpSide4[3].x = 200;
   lpSide4[3].y = 200;

   Polyline(hDC, lpSide1, 4);  /*  Draw the sides of the box  */
   Polyline(hDC, lpSide2, 4);
   Polyline(hDC, lpSide3, 4);
   Polyline(hDC, lpSide4, 4);

   ValidateRect (hWnd, (LPRECT) NULL);
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   return TRUE;
 }




 POSTMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\POSTMSG.C

 /*
  *  PostMessage
  *
  *  This example program will use the PostMessage function to send a
  *  WM_SYSCOMMAND message to the main window to make it iconic.  The
  *  wParam parameter will be set to SC_MINIMIZE to accomplish this.
  *
  */

 #include "windows.h"
 #include "postmsg.h"

 HANDLE hInst;

 int  PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR lpCmdLine;
 int  nCmdShow;
 {
   HWND hWnd;
   MSG msg;
   HANDLE hMenu;

   if (!hPrevInstance)
     if (!PostMsgInit(hInstance))
       return (NULL);

   hInst = hInstance;

   hMenu = LoadMenu(hInst, (LPSTR)"PostMsgMenu");


   hWnd = CreateWindow((LPSTR)"PostMsg", (LPSTR)"PostMessage Sample Applicatio
   WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, hMenu, hInstance, NULL);

   if (!hWnd)
     return (NULL);

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

   while (GetMessage(&msg,
       NULL,
       NULL,
       NULL))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam);
 }


 BOOL PostMsgInit(hInstance)
 HANDLE hInstance;
 {
   HANDLE hMemory;
   PWNDCLASS pWndClass;
   BOOL bSuccess;

   hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
   pWndClass = (PWNDCLASS) LocalLock(hMemory);

   pWndClass->style = NULL;
   pWndClass->lpfnWndProc = PostMsgWndProc;
   pWndClass->hInstance = hInstance;
   pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
   pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
   pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
   pWndClass->lpszMenuName = (LPSTR) "PostMsgMenu";
   pWndClass->lpszClassName = (LPSTR) "PostMsg";

   bSuccess = RegisterClass(pWndClass);

   LocalUnlock(hMemory);
   LocalFree(hMemory);

   return (bSuccess);
 }


 long  FAR PASCAL PostMsgWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   FARPROC lpProcAbout;
   HMENU hMenu;

   switch (message)
   {
   case WM_SYSCOMMAND:
     if (wParam == ID_ABOUT)
     {
       lpProcAbout = MakeProcInstance(About, hInst);

       DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);

       FreeProcInstance(lpProcAbout);
       break;
     }

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

   case WM_CREATE:

     hMenu = GetSystemMenu(hWnd, FALSE);

 /* Add a separator to the menu */

     ChangeMenu(hMenu, NULL, NULL, NULL, MF_APPEND | MF_SEPARATOR);

 /* Add new menu item to the System menu */

     ChangeMenu(hMenu, NULL, "A&bout PostMsg...", ID_ABOUT,
         MF_APPEND | MF_STRING);
     break;

   case WM_COMMAND:
     if (wParam == IDM_ICONIZE)
     {
       PostMessage(hWnd, WM_SYSCOMMAND, SC_MINIMIZE, (LONG) NULL);
     }
     break;

 /*  PostMessage places the message into the applications message queue and
  *  does not wait for a response.  This is different from the SendMessage
  *  function in that SendMessage does wait.  The Window Procedure is called
  *  immediately when SendMessage is used.  For more information see
  *  PostMessage and SendMessage in the Programmer's Reference.
  */
   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return (DefWindowProc(hWnd, message, wParam, lParam));
   }
   return (NULL);
 }


 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_INITDIALOG:
     return (TRUE);

   case WM_COMMAND:
     if (wParam == IDOK)
     {
       EndDialog(hDlg, NULL);
       return (TRUE);
     }
     break;
   }
   return (FALSE);
 }




 POSTQUIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\POSTQUIT.C

 /* PostQuitMessage
  *
  *  When Execute is selected, a PostQuitMessage is generated and
  *  closes down this application.
  *
  */

 #include <windows.h>
 #include "postquit.h"

 long  FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 static char  szResName [] = "ResMenu";

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int  nCmdShow ;
 {
   static char  szAppName [] = "PostQuitMessage";
   HWND        hWnd ;
   MSG msg;
   WNDCLASS  wcPostQuitMessageClass;

   wcPostQuitMessageClass.lpszClassName = szAppName;
   wcPostQuitMessageClass.hInstance     = hInstance;
   wcPostQuitMessageClass.lpfnWndProc   = WndProc;
   wcPostQuitMessageClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wcPostQuitMessageClass.hIcon         = NULL;
   wcPostQuitMessageClass.lpszMenuName  = (LPSTR) NULL;
   wcPostQuitMessageClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPostQuitMessageClass.style         = CS_HREDRAW | CS_VREDRAW;
   wcPostQuitMessageClass.cbClsExtra    = 0;
   wcPostQuitMessageClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) & wcPostQuitMessageClass);

   hWnd = CreateWindow(szAppName, (LPSTR) "PostQuitMessage",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL, NULL,  hInstance, NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   static HANDLE hInstance;
   HMENU hMenu;
   switch (iMessage)
   {
   case WM_CREATE:
     {
       hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
       hMenu = LoadMenu(hInstance, "ResMenu");
       SetMenu(hWnd, hMenu);
       DrawMenuBar(hWnd);
       break;
     }
   case WM_COMMAND:
     {
       switch (wParam)
       {
       case IDM_EXECUTE:
   {
     PostQuitMessage(0);
   }
       }
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
   }
   return (0L);
 }




 PROCINST.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\PROCINST.C

 /*
  *
  *  FreeProcInstance
  *
  *  This program demonstrates the use of the function FreeProcInstance.
  *  This function frees the function specified bye the parameter from the
  *  data segment bound to it by the MakeProcInstance function.
  *
  *  Other references: DlgOpen.c, DlgSave.c, Print.c
  */

 #include <windows.h>
 #include "procinst.h"

 typedef struct  {
   int  nDummy;
 } SETUPDATA;

 static SETUPDATA strSetUpData;
 static HANDLE hInst;
 static char  szFileName[] = "procinst";
 static char  szFuncName[] = "FreeProcInstance";

 long  FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);
 BOOL FAR PASCAL TestFarFunc ();

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  cmdShow;
 {
   HWND hWnd;
   MSG  msg;
   if (!hPrevInstance)
   {
     WNDCLASS rClass;

     rClass.style         = CS_HREDRAW | CS_VREDRAW;
     rClass.lpfnWndProc   = WndProc;
     rClass.cbClsExtra    = 0;
     rClass.cbWndExtra    = 0;
     rClass.hInstance     = hInstance;
     rClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon         = LoadIcon (hInstance, IDI_APPLICATION);
     rClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.lpszClassName = (LPSTR) szFileName;

     RegisterClass ((LPWNDCLASS) & rClass);
   }
   else
     GetInstanceData (hPrevInstance, (PSTR) & strSetUpData,
         sizeof (SETUPDATA));

   hInst = hInstance;

   hWnd = CreateWindow ((LPSTR) szFileName, (LPSTR) szFuncName,
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }
   exit(msg.wParam);
 }


 BOOL FAR PASCAL TestFarFunc ()
 {
   return TRUE;
 }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  static HANDLE hInstance;
  FARPROC  lpProc;
  HMENU hMenu;
  switch(iMessage)
  {
   case WM_CREATE:
   {
    hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
    hMenu = LoadMenu(hInstance, "ResMenu");
    SetMenu(hWnd, hMenu);
    DrawMenuBar(hWnd);
    break;
   }
   case WM_COMMAND:
   {
    switch(wParam)
    {
     case IDM_EXECUTE:
     {
     lpProc = MakeProcInstance ((FARPROC) TestFarFunc, hInst);
     MessageBox (NULL, (LPSTR)"Freeing procedure instance", (LPSTR)szFuncName,
     FreeProcInstance (lpProc);
     MessageBox (NULL, (LPSTR)"Instance procedure freed", (LPSTR)szFuncName, M
     }
    }
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 PROPERTY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\PROPERTY.C

 /*

 Function(s) demonstrated in this program: SetProp, GetProp, RemoveProp

 Description:

 This program demonstrates the use of the function SetProp, GetProp,
 and RemoveProp.  SetProp copies the character string and a data handle
 to the property list of the window.  This has the effect of
 associating a data object with the window.  The string serves as a
 label for the data handle.  The data handle is retrieved from the
 property list using the GetProp function and specifying the character
 string.  Before the window is destroyed the RemoveProp function must
 be used  to remove the single entry in the property list.  Note that there
 may be more than one data items associated with a window in the property
 list.

 */

 #include <windows.h>
 #include <stdio.h>
 #include <string.h>
 #include "property.h"

 VOID FAR PASCAL lstrcpy(LPSTR, LPSTR);
 long  FAR PASCAL WndProc(HWND, unsigned, WORD, long);

 /* This is the structure that is used to put into the property list. */
 typedef struct tagData {
   short  nRow, nSeat;
   char  szName[20];
 } SEATINGS;
 static char  szResName [] = "ResMenu";

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int  nCmdShow ;
 {
   static char  szAppName [] = "Property" ;
   HWND        hWnd ;
   WNDCLASS    wndclass ;
   MSG msg;

   if (!hPrevInstance)
   {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = NULL ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
       return FALSE ;
   }

   hWnd = CreateWindow(szAppName, (LPSTR)"Setting the Property List",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0,
       NULL, NULL, hInstance, NULL) ;

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

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return (msg.wParam) ;
 }


 long  FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned  iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
   static HANDLE hInstance;
   HANDLE hData;
   HMENU hMenu;
   char  szbuffer[200], szName[20];
   short  nRow, nSeat;
   SEATINGS FAR * pstrSeatings;
   switch (iMessage)
   {
   case WM_CREATE:
     {
       hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
       hMenu = LoadMenu(hInstance, "ResMenu");
       SetMenu(hWnd, hMenu);
       DrawMenuBar(hWnd);
       break;
     }
   case WM_COMMAND:
     {
       switch (wParam)
       {
       case IDM_EXECUTE:
   {
 /* Putting the structure into the property list of the window
  * If it is successful, retrieve it to check if the correct structure
  * is put into the property list
  */
     hData = GlobalAlloc(GMEM_MOVEABLE, (LONG)sizeof(SEATINGS));


 /* Initialize the data structure to be associated with the window */

     pstrSeatings = (SEATINGS FAR * )GlobalLock(hData);
     pstrSeatings->nRow = 4;
     pstrSeatings->nSeat = 2;
     lstrcpy (pstrSeatings->szName, "John Smith");

     GlobalUnlock(hData);
 /* Add a new entry into the property list of the window specified *
  * by hWnd. The character string "Smith" identifies the entry to  *
  * be added.
  */
     if (!SetProp(hWnd, "Smith", hData))
       MessageBox(hWnd, (LPSTR)"The Windows function SetProp failed.",
           (LPSTR)"FAIL", MB_OK | MB_ICONHAND);

 /* Prepare to display message */
     sprintf (szbuffer, "The following entry has been added to the \
 property list of the parent window using the Windows function \
 SetProp.\n\n  Smith at row 4, seat# 2\n");


     MessageBox(hWnd, szbuffer, "SetProp", MB_OK);

 /* Retrieve an entry from the property list of the window specified *
  * by hWnd. The character string "Smith" identifies the entry to    *
  * be retrieved.
  */
     hData = GetProp(hWnd, "Smith");

     if (!hData)
     {
       MessageBox(hWnd, "GetProp has failed", "GetProp", MB_OK | MB_ICONHAND);
     }

     pstrSeatings = (SEATINGS FAR * )GlobalLock(hData);

 /* Copy the global data objects into local data structures so that *
  * we can use sprintf.  Using small memory model, sprintf will     *
  * only accept pointer offsets into the current data segment
  */
     nRow = pstrSeatings->nRow;
     nSeat =  pstrSeatings->nSeat;
     lstrcpy(szName, pstrSeatings->szName);


 /* Prepare to display message */

     sprintf(szbuffer, "The following entry has been retrieved from the \
 property list of the parent window using the Windows function GetProp.\n\n \
 %s at row %d, seat# %d\n",
                      szName, nRow, nSeat);

     MessageBox(hWnd, szbuffer, "GetProp", MB_OK);

     GlobalUnlock(hData);
     GlobalFree(hData);

 /* Remove an entry from the property list of the window specified *
  * by hWnd. The character string "Smith" identifies the entry to  *
  * be removed.
  */
     if (!RemoveProp(hWnd, "Smith"))
     {
       MessageBox(hWnd, "RemoveProp has failed",
           "RemoveProp", MB_OK | MB_ICONHAND);
     }

 /* Prepare to display message */
     sprintf(szbuffer, "The following entry has been removed from the \
 property list of the parent window using the Windows function \
 RemoveProp.\n\n %s at row %d, seat# %d\n",
                      szName, nRow, nSeat);

     MessageBox (hWnd, szbuffer, "RemoveProp", MB_OK);

   }
       }
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
   }
   return (0L);
 }




 PTVISI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIENT\PTVISI.C

 /*
  *  PtVisible
  *
  *  This function demonstrates the use of the PtVisible function.  It will
  *  create a window using the CreateWindow function, and will display a
  *  message box telling the user if the point (200,200) is inside the client
  *  area of the window.
  *
  */

 #include <windows.h>

 BOOL FAR PASCAL InitPtVisible (HANDLE, HANDLE, int);
 long  FAR PASCAL PtVisibleWindowProc (HANDLE, unsigned, WORD, LONG);
 void FAR PASCAL CheckPoint (HWND);

 int  PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)

 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int  nCmdShow;
 {
   MSG  msg;

   InitPtVisible (hInstance, hPrevInstance, nCmdShow);

   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   exit(msg.wParam);
 }


 BOOL FAR PASCAL InitPtVisible (hInstance, hPrevInstance, nCmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int  nCmdShow;

 {
   WNDCLASS  wcPtVisibleClass;
   HWND hWnd;

   wcPtVisibleClass.lpszClassName = (LPSTR) "PtVisible";
   wcPtVisibleClass.hInstance  = hInstance;
   wcPtVisibleClass.lpfnWndProc  = PtVisibleWindowProc;
   wcPtVisibleClass.hCursor  = LoadCursor (NULL, IDC_ARROW);
   wcPtVisibleClass.hIcon  = NULL;
   wcPtVisibleClass.lpszMenuName  = (LPSTR) "PtVisibleMenu";
   wcPtVisibleClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcPtVisibleClass.style  = CS_HREDRAW | CS_VREDRAW;
   wcPtVisibleClass.cbClsExtra  = 0;
   wcPtVisibleClass.cbWndExtra  = 0;

   RegisterClass ((LPWNDCLASS) & wcPtVisibleClass);

   hWnd = CreateWindow((LPSTR) "PtVisible", (LPSTR) "PtVisible",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,  0,
       CW_USEDEFAULT,  0,
       NULL,  NULL,  hInstance, NULL);

   LoadMenu(hInstance, (LPSTR) "PtVisibleMenu");

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

   return TRUE;
 }


 long  FAR PASCAL PtVisibleWindowProc (hWnd, message, wParam, lParam)

 HWND     hWnd;
 unsigned  message;
 WORD     wParam;
 LONG     lParam;
 {
   switch (message)
   {
   case WM_COMMAND:
     if (wParam == 1)
       CheckPoint(hWnd);
     break;

   case WM_PAINT:
     PaintPtVisibleWindow (hWnd);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   default:
     return(DefWindowProc(hWnd, message, wParam, lParam));
     break;
   }
   return(0L);
 }


 PaintPtVisibleWindow (hWnd)

 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC  hDC;

   BeginPaint (hWnd, (LPPAINTSTRUCT) & ps);
   hDC = ps.hdc;

   SetPixel (hDC, 200, 200, RGB(0, 0, 0));
 /*  Draw a black pixel  */

   ValidateRect (hWnd, (LPRECT) NULL);
   EndPaint (hWnd, (LPPAINTSTRUCT) & ps);

   return TRUE;
 }


 /*  CheckPoint(hWnd) -  Check to see if (200, 200) is visible  */

 void FAR PASCAL CheckPoint (hWnd)

 HWND     hWnd;
 {
   HDC  hDC;

   hDC = GetDC (hWnd);
   if (PtVisible (hDC, 200, 200))
 /*  Find out if the point 200, 200 is in the current display
      *  context
      */

     MessageBox(hWnd, (LPSTR) "(200, 200) is Visible",
         (LPSTR)"OK", MB_OK);
   else
     MessageBox(hWnd, (LPSTR) "(200, 200) is not Visible",
         (LPSTR)"OK", MB_OK);

   ReleaseDC (hWnd, hDC);
 }




 QCHECKED.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\QCHECKED.C

 /*
  *
  *   qchecked.c
  *
  *   This program demonstrates the use of the IsDlgButtonChecked function.
  *   IsDlgButtonChecked checks to see if the given button control or 3 state
  *   button is checked. That is not the same as seeing if the control has
  *   been chosen. To enact the dialog box, choose the "DIALOG" menu
  *   selection. To invoke a call to IsDlgButtonChecked,choose one of the two
  *   check boxes in the dialog box.
  *
  */

 #include "windows.h"
 #include "qchecked.h"

 HANDLE hInst;

 FARPROC lpprocDialog;
 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL DialogBoxProc(HWND, unsigned, WORD, LONG);


 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int   cmdShow;
   {
   MSG      msg;
   HWND      hWnd;
   HMENU     hMenu;
   WNDCLASS  wndclass;

   if (!hPrevInstance)
     {
     wndclass.style      = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc    = WndProc;
     wndclass.cbClsExtra     = 0;
     wndclass.cbWndExtra     = 0;
     wndclass.hInstance      = hInstance;
     wndclass.hIcon      = NULL;
     wndclass.hCursor      = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground  = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName  = "Sample Application";

     if (!RegisterClass(&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow("Sample Application",
           "IsDlgItemChecked",
           WS_OVERLAPPEDWINDOW,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           NULL,
           NULL,
           hInstance,
           NULL);

   hInst = hInstance;
   lpprocDialog = MakeProcInstance((FARPROC)DialogBoxProc, hInst);
   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);
   hMenu = LoadMenu(hInstance, "qchecked");
   SetMenu(hWnd, hMenu);

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   FreeProcInstance (lpprocDialog);
   return msg.wParam;
   }


 long FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned   message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       if (wParam == 80)
         {
         DialogBox(hInst, MAKEINTRESOURCE(2), hWnd, lpprocDialog);
         break;
         }
       else
         return DefWindowProc(hWnd, message, wParam, lParam);

     case WM_DESTROY:
       FreeProcInstance((FARPROC)lpprocDialog);
       PostQuitMessage(0);
       break;

     default:
       return DefWindowProc(hWnd, message, wParam, lParam);
     }
   return(0L);
   }


 BOOL FAR PASCAL DialogBoxProc(hDlg, message, wParam, lParam)
 HWND    hDlg;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   HWND hCtl;

   switch (message)
     {
     case WM_INITDIALOG:
       SendDlgItemMessage(hDlg, TOP_CONTROL, BM_SETCHECK, TRUE, (LONG) 0);
       return TRUE;
       break;

     case WM_COMMAND:
       switch (wParam)
   {
   case TOP_CONTROL:
     if (IsDlgButtonChecked(hDlg, TOP_CONTROL))
             MessageBox(GetFocus(), "IS checked", "The top control:", MB_OK);
     else
             MessageBox(GetFocus(), "is NOT checked", "The top control:", MB_O
           break;

   case BOTTOM_CONTROL:
     if (IsDlgButtonChecked(hDlg, BOTTOM_CONTROL))
             MessageBox(GetFocus(), "IS checked", "The bottom control:", MB_OK
     else
             MessageBox(GetFocus(), "is NOT checked", "The bottom control:",
                        MB_OK);
           break;

   case ID_OK:
     EndDialog(hDlg, TRUE);
           break;

   default:
     MessageBox(NULL, "oops", NULL, MB_OK);
     return FALSE;
         }
       break;

     default:
       return FALSE;
     }
   }


 QENABLED.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\QENABLED.C

 /*
  *
  *   qenabled.c
  *
  *   This program demonstrates the use of the IsWindowEnabled function.
  *   IsWindowEnabled checks to see if the given window is enabled to receive
  *   input. Each window in this application, if enabled, should display a
  *   message box in response to a left button click. IsWindowEnabled is calle
  *   from WinMain in this sample application.
  */

 #include "windows.h"

 long  FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);
 long  FAR PASCAL ChildAProc(HWND, unsigned, WORD, LONG);
 long  FAR PASCAL ChildBProc(HWND, unsigned, WORD, LONG);

 HWND hChAWnd = NULL;
 HWND hChBWnd = NULL;


 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE   hInstance, hPrevInstance;
 LPSTR   lpszCmdLine;
 int  cmdShow;
 {
   MSG      msg;
   HWND      hWnd;
   HMENU     hMenu;
   BOOL      bEnabled;
   WNDCLASS  wndclass;

   if (!hPrevInstance)
   {
     wndclass.style     = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = WndProc;
     wndclass.cbClsExtra   = 0;
     wndclass.cbWndExtra   = 0;
     wndclass.hInstance   = hInstance;
     wndclass.hIcon     = NULL;
     wndclass.hCursor   = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground   = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName   = "Sample Application";

     if (!RegisterClass(&wndclass))
       return FALSE;

     wndclass.style     = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = ChildAProc;
     wndclass.cbClsExtra   = 0;
     wndclass.cbWndExtra   = 0;
     wndclass.hInstance   = hInstance;
     wndclass.hIcon     = NULL;
     wndclass.hCursor   = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground   = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName   = "CHILD A";

     if (!RegisterClass(&wndclass))
       return FALSE;

     wndclass.style     = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc   = ChildBProc;
     wndclass.cbClsExtra   = 0;
     wndclass.cbWndExtra   = 0;
     wndclass.hInstance   = hInstance;
     wndclass.hIcon     = NULL;
     wndclass.hCursor   = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground   = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName   = "CHILD B";

     if (!RegisterClass(&wndclass))
       return FALSE;
   }

   hWnd = CreateWindow("Sample Application",
       "IsWindowEnabled",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);
   ShowWindow(hWnd, cmdShow);
   UpdateWindow(hWnd);

   hChAWnd = CreateWindow("CHILD A",
       "Child A",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION | WS_CLIPSIBLINGS,
       5,
       5,
       150,
       150,
       hWnd,
       (HMENU)1,
       hInstance,
       NULL);

   hChBWnd = CreateWindow("CHILD B",
       "Child B",
       WS_CHILD | WS_SIZEBOX | WS_VISIBLE | WS_CAPTION | WS_CLIPSIBLINGS,
       270,
       5,
       150,
       150,
       hWnd,
       (HMENU)2,
       hInstance,
       NULL);

   MessageBox(hWnd,
       "if Child A is enabled",
       "I am going to see...",
       MB_OK);
   if (IsWindowEnabled(hChAWnd))
     MessageBox(hWnd,
         "Child A IS enabled",
         "'IsWindowEnabled' says...",
         MB_OK);
   else
     MessageBox(hWnd,
         "Child A is NOT enabled",
         "'IsWindowEnabled' says...",
         MB_OK);
   MessageBox(hWnd,
       "disable Child B",
       "I am going to...",
       MB_OK);
   EnableWindow(hChBWnd, FALSE);
   MessageBox(hWnd,
       "if Child B is enabled",
       "I am going to see...",
       MB_OK);
   if (IsWindowEnabled(hChBWnd))
     MessageBox(hWnd,
         "Child B IS enabled",
         "'IsWindowEnabled' says...",
         MB_OK);
   else
     MessageBox(hWnd,
         "Child B is NOT enabled",
         "'IsWindowEnabled' says...",
         MB_OK);

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }

   return msg.wParam;
 }


 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
 {
   switch (message)
   {
   case WM_LBUTTONDOWN:
     {
       MessageBox(hWnd,
           "Left Button Click",
           "PARENT WINDOW",
           MB_OK);
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return(0L);
 }


 long  FAR PASCAL ChildAProc(hChAWnd, message, wParam, lParam)
 HWND hChAWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_LBUTTONDOWN:
     MessageBox(hChAWnd, (LPSTR)"Left Button Click",
         (LPSTR)"CHILD A",
         MB_OK);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   case WM_PAINT:
     BeginPaint(hChAWnd, (LPPAINTSTRUCT) & ps);
     EndPaint(hChAWnd, (LPPAINTSTRUCT) & ps);
     break;

   default:
     return DefWindowProc(hChAWnd, message, wParam, lParam);
     break;
   }
   return(0L);
 }


 long  FAR PASCAL ChildBProc(hChBWnd, message, wParam, lParam)
 HWND hChBWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   PAINTSTRUCT ps;

   switch (message)
   {

   case WM_LBUTTONDOWN:
     MessageBox(hChBWnd, (LPSTR)"Left Button Click",
         (LPSTR)"CHILD B",
         MB_OK);
     break;

   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   case WM_PAINT:
     BeginPaint(hChBWnd, (LPPAINTSTRUCT) & ps);
     EndPaint(hChBWnd, (LPPAINTSTRUCT) & ps);
     break;

   default:
     return DefWindowProc(hChBWnd, message, wParam, lParam);
     break;
   }
   return(0L);
 }




 QUIT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\QUIT.C

 /*
  *
  *  QUIT - Demonstrates PostAppMessage and GetWindowTask
  *
  *  This program will get the Task handle to the current Window, and send
  *  a WM_QUIT message to the window which will cause it to go away.
  */

 #include <windows.h>
 #define IDM_QUIT    100

 HANDLE hInst;

 int PASCAL WinMain(HANDLE, HANDLE, LPSTR, int);
 long FAR PASCAL QuitWndProc(HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL About(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE   hInstance;
 HANDLE   hPrevInstance;
 LPSTR   lpCmdLine;
 int   nCmdShow;
   {
   HWND      hWnd;
   MSG      msg;
   HANDLE    hMenu;
   WNDCLASS  wndclass;
   if (!hPrevInstance)
     {
     wndclass.style      = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc    = QuitWndProc;
     wndclass.cbClsExtra     = 0;
     wndclass.cbWndExtra     = 0;
     wndclass.hInstance      = hInstance;
     wndclass.hIcon      = LoadIcon(NULL, IDI_APPLICATION);
     wndclass.hCursor      = LoadCursor(NULL, IDC_ARROW);
     wndclass.hbrBackground  = GetStockObject(WHITE_BRUSH);
     wndclass.lpszMenuName   = "QuitMenu";
     wndclass.lpszClassName  = "Quit";

     if (!RegisterClass(&wndclass))
       return FALSE;
     }
   hInst = hInstance;               /* Saves the current instance        */

   hMenu = LoadMenu(hInst, "QuitMenu");

   hWnd = CreateWindow("Quit",
           "Quit Sample Application",
           WS_OVERLAPPEDWINDOW,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           CW_USEDEFAULT,
           NULL,
           hMenu,
           hInstance,
           NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return msg.wParam;
   }


 long FAR PASCAL QuitWndProc(hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   HANDLE  hTask;

   switch (message)
     {
     case WM_COMMAND:
       if (wParam == IDM_QUIT)
   {
   hTask = GetWindowTask(hWnd);
   PostAppMessage(hTask, WM_QUIT, 0, 0L);
   }
       break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return (DefWindowProc(hWnd, message, wParam, lParam));
     }
   return (NULL);
   }


 QVISIBLE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\QVISIBLE.C

 /*
  *
  *   qvisible.c
  *
  *   This program demonstrates the use of the IsWindowVisible function.
  */

 #include "windows.h"

 long    FAR PASCAL WndProc (HWND, unsigned, WORD, LONG);
 long    FAR PASCAL ChildProc (HWND, unsigned, WORD, LONG);

 HWND hChildWnd = NULL;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE     hInstance, hPrevInstance;
 LPSTR      lpszCmdLine;
 int        cmdShow;
   {
   MSG      msg;
   HWND      hWnd;
   HMENU     hMenu;
   WNDCLASS  wndclass;

   if (!hPrevInstance)
     {
     wndclass.style      = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc    = WndProc;
     wndclass.cbClsExtra     = 0;
     wndclass.cbWndExtra     = 0;
     wndclass.hInstance      = hInstance;
     wndclass.hIcon      = NULL;
     wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName  = "Sample Application";

     if (!RegisterClass (&wndclass))
       return FALSE;

     wndclass.style      = CS_HREDRAW | CS_VREDRAW;
     wndclass.lpfnWndProc    = ChildProc;
     wndclass.cbClsExtra     = 0;
     wndclass.cbWndExtra     = 0;
     wndclass.hInstance      = hInstance;
     wndclass.hIcon      = NULL;
     wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW);
     wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     wndclass.lpszMenuName   = NULL;
     wndclass.lpszClassName  = "CHILD";

     if (!RegisterClass (&wndclass))
       return FALSE;
     }

   hWnd = CreateWindow ("Sample Application",
       "IsWindowVisible",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   hChildWnd = CreateWindow ("CHILD",
       "Child",
       WS_CHILD | WS_SIZEBOX | WS_CAPTION | WS_CLIPSIBLINGS,
       5,
       5,
       150,
       150,
       hWnd,
       (HMENU)1,
       hInstance,
       NULL);

   MessageBox (hWnd, "the child window is visible", "I am going to see if...",
              MB_OK);
   if (IsWindowVisible (hChildWnd))
     MessageBox (hWnd, "the child window IS visible",
         "'IsWindowVisible' says...", MB_OK);
   else
     MessageBox (hWnd, "the child window is NOT visible",
         "'IsWindowVisible' says...", MB_OK);

   ShowWindow (hChildWnd, SW_SHOWNORMAL);

   MessageBox (hWnd, "the child window is visible",
              "I am going to see if...", MB_OK);

   if (IsWindowVisible (hChildWnd))
     MessageBox (hWnd, "the child window IS visible",
         "'IsWindowVisible' says...", MB_OK);
   else
     MessageBox (hWnd, "the child window is NOT visible",
                 "'IsWindowVisible' says...", MB_OK);

   while (GetMessage (&msg, NULL, 0, 0))
     {
     TranslateMessage (&msg);
     DispatchMessage (&msg);
     }
   return msg.wParam;
   }


 long    FAR PASCAL WndProc (hWnd, message, wParam, lParam)
 HWND    hWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   switch (message)
     {
     case WM_LBUTTONDOWN:
       MessageBox (hWnd, "Left Button Click", "PARENT WINDOW", MB_OK);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hWnd, message, wParam, lParam);
     }
   return (0L);
   }

 long    FAR PASCAL ChildProc (hChildWnd, message, wParam, lParam)
 HWND    hChildWnd;
 unsigned  message;
 WORD    wParam;
 LONG    lParam;
   {
   switch (message)
     {
     case WM_LBUTTONDOWN:
       MessageBox (hChildWnd, (LPSTR)"Left Button Click", (LPSTR)"CHILD A",
                   MB_OK);
       break;

     case WM_DESTROY:
       PostQuitMessage (0);
       break;

     default:
       return DefWindowProc (hChildWnd, message, wParam, lParam);
       break;
     }
   return (0L);
   }


 RCLASS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\RCLASS.C

 /*
  *  RegisterClass
  *  This function demonstrates the use of the RegisterClass function.  It wil
  *  register a window Class, and then display that window.
  *
  */

 #include <windows.h>


 long  FAR PASCAL WndProc (HANDLE, unsigned, WORD, LONG);

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR    lpszCmdLine;
 int  nCmdShow;
 {
   WNDCLASS  wcClass;
   MSG      msg;
   HWND      hWnd;

   if (!hPrevInstance)
   {
     wcClass.lpszClassName = "WndClass";
     wcClass.hInstance    = hInstance;
     wcClass.lpfnWndProc   = WndProc;
     wcClass.hCursor    = LoadCursor (NULL, IDC_ARROW);
     wcClass.hIcon    = NULL;
     wcClass.lpszMenuName  = NULL;
     wcClass.hbrBackground = GetStockObject (WHITE_BRUSH);
     wcClass.style    = CS_HREDRAW | CS_VREDRAW;
     wcClass.cbClsExtra    = 0;
     wcClass.cbWndExtra    = 0;

     if (!RegisterClass (&wcClass))
       return FALSE;
   }

   hWnd = CreateWindow("WndClass",
       "RegisterClass",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       NULL,
       NULL,
       hInstance,
       NULL);

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

   while (GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return msg.wParam;
 }


 long  FAR PASCAL WndProc(hWnd, message, wParam, lParam)
 HWND      hWnd;
 unsigned  message;
 WORD      wParam;
 LONG      lParam;
 {
   PAINTSTRUCT   ps;
   HDC           hDC;
   HWND    hButton;
   HANDLE  hInst;
   short  xChar,
   yChar;
   TEXTMETRIC  tm;
   WNDCLASS  wndclass;
   BOOL    bRegClass;

   hInst = GetWindowWord(hWnd, GWW_HINSTANCE);
   switch (message)
   {
   case WM_CREATE:
     {
       hDC = GetDC(hWnd);
       GetTextMetrics(hDC, &tm);
       xChar = tm.tmAveCharWidth;
       yChar = tm.tmHeight + tm.tmExternalLeading;
       ReleaseDC(hWnd, hDC);
       hButton = CreateWindow("button",
           "Register Window Class",
           WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
           xChar * 20,
           yChar * 7,
           xChar * 23,
           yChar * 3,
           hWnd,
           0,
           hInst,
           NULL);
       break;
     }
   case WM_COMMAND:
     {
       if (wParam == 0)
       {
   MessageBox(hWnd,
       "Registering window\nclass FooClass:",
       "RegisterClass()",
       MB_OK);
   wndclass.lpszClassName = "FooClass";
   wndclass.hInstance     = hInst;
   wndclass.lpfnWndProc   = DefWindowProc;
   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wndclass.hIcon         = NULL;
   wndclass.lpszMenuName  = NULL;
   wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wndclass.style         = CS_HREDRAW | CS_VREDRAW;
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = 0;

   bRegClass = RegisterClass(&wndclass);
   if (bRegClass)
     MessageBox(hWnd,
         "Window class FooClass\nhas been registered.\nAll re-registration\nat
         "RegisterClass()",
         MB_ICONASTERISK);
   else
     MessageBox(hWnd,
         "Registration failed.\nThe class is already\nregistered.",
         "RegisterClass()",
         MB_ICONEXCLAMATION);
       }
       break;
     }
   case WM_DESTROY:
     {
       PostQuitMessage(0);
       break;
     }
   default:
     return(DefWindowProc(hWnd, message, wParam, lParam));
   }
   return(0L);
 }




 READCOMM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\READCOMM.C

 /*
  *  ReadComm
  *  This program demonstrates the use of the function ReadComm.
  *  It attempts to read a specified number of characters from the
  *  communication device that has already been opened and copy the
  *  characters into a buffer. Before attempting to do any read, the
  *  communication device must have its device control block set up
  *  properly to a correct configuration.
  *
  *  This program will only run properly if there is a dumb terminal connected
  *  to COM1: port.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Readcomm";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND    hWnd;          /* Handle to the parent window             */
     short   nCid;          /* Short integer identifying the opened
                             * communication device                    */
     short   nBytes;        /* The number of characters read           */
     char    szBuffer[20];  /* The buffer that is recieving the
                             * characters to be read                   */
     HDC     hDC;           /* Handle to the DC of the client area     */
     DCB     dcb;           /* The device control block                */
     COMSTAT cstat;         /* The current status of the communication
                             * device                                  */

     WinInit( hInstance );

     hWnd = CreateWindow((LPSTR)"Readcomm",
                         (LPSTR)"Read from Communication Devices",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* attempt to open the com1 port */
     nCid = OpenComm ((LPSTR)"COM1", 20, 20);
     if (nCid < 0)
       {
          MessageBox (hWnd, (LPSTR)"Com port not opened!!",(LPSTR)"FAIL!",MB_O
          return 0;
       }

     /* the communication device control block must be set to the appropriate
      * settings of the other dumb terminal in order to read and write
      * properly
      */
     if (GetCommState (nCid, (DCB FAR *) &dcb) >= 0)
       { dcb.BaudRate = 9600;
         dcb.ByteSize = 8;
         dcb.StopBits = ONESTOPBIT;
         dcb.Parity   = NOPARITY;
         dcb.fRtsflow = FALSE;
         dcb.fDtrflow = FALSE;
         dcb.fOutX    = FALSE;
         dcb.fInX     = FALSE;
         dcb.fNull    = FALSE;
         dcb.XonLim   = 1;
         dcb.XoffLim  = 20;
       }

     SetCommState ((DCB FAR *) &dcb);

     /* Put something into the transmit queue of the dumb terminal */
     MessageBox (hWnd, (LPSTR)"Type in something at the other terminal",
                 (LPSTR)"Quick", MB_OK);

     /* attempt to read from the recieve queue of the communication device */
     nBytes = ReadComm (nCid, (LPSTR)szBuffer, 20);

     /* in case of an overflow of the recieve queue, GetCommError is
      * called to clear the error condition,; otherwise no other communication
      * function will work properly
      */
     if (GetCommError (nCid, (COMSTAT FAR *) &cstat) == CE_RXOVER)
       {  MessageBox (hWnd, (LPSTR)"Receive Queue overflow", (LPSTR)"ERROR!!",

          /* The error code must be cleared first before reading the receive
           * queue again
           */
          nBytes = ReadComm (nCid, (LPSTR)szBuffer, 20);
       }

     /* Check to see if the read is successfully */
     if (nBytes == 0)
       MessageBox (hWnd, (LPSTR)"No character in the recieve queue",
                     (LPSTR)"None Read", MB_OK);

     if (nBytes > 0)
       { hDC = GetDC (hWnd);
         TextOut (hDC, 10, 10, (LPSTR)szBuffer, nBytes);
         ReleaseDC (hWnd, hDC);
         MessageBox (hWnd,
                     (LPSTR)"Some characters read from the recieve queue",
                     (LPSTR)"Read", MB_OK);
       }

     if (nBytes < 0)
       MessageBox (hWnd, (LPSTR)"Nothing read", (LPSTR)NULL, MB_OK);


     /* must close the communication device before leaving the program */
     CloseComm (nCid);

     return 0;
 }


 RECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\RECT.C

 /*

 Function(s) demonstrated in this program: SetRectEmpty, UnionRect, OffsetRect

 Description:  The SetRectEmpty sets all the fields of a rectangle structure
     to 0.  The UnionRect function takes two rectangle structures, and
     places in a third rectangle structure the coordinates of the smallest
     rectangle which contains both of the other rectangles.  The OffsetRect
     function adjusts the coordinates of the rectangle structrure by the
     offsets supplied.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <math.h>
 #include <stdio.h>
 #include "Rect.h"

 #define PI 3.14159265


 char    szRadius  [15];
 HANDLE  hInstMain;
 FARPROC lpProcGetRadius;
 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];
 HWND     hWndMain, hX, hY, hOK2;
 FARPROC  lpProcEnterPoint;
 FARPROC  lpProcNewEnterPoint;
 FARPROC  lpProcOldX;
 FARPROC  lpProcOldY;
 char     szXValue [40];
 char     szYValue [40];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of the SetRectEmpty, UnionRect, and OffsetRect\n\
 Windows functions.",

 "Help Message",
 "     This program uses the Windows functions\n\
 SetRectEmpty, UnionRect, and OffsetRect.  There are\n\
 three rectangles displayed in the window.  Two of\n\
 these windows are adjustable, and the third is\n\
 a union of the first two.  Use the menu to\n\
 adjust the size and position of the two rectangles\n\
 in pixels.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     static char szAppName[] = "Rect";
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;

     if (!hPrevInstance)  {
         wndclass.style          = CS_HREDRAW | CS_VREDRAW;
         wndclass.lpfnWndProc    = WndProc;
         wndclass.cbClsExtra     = 0;
         wndclass.cbWndExtra     = 0;
         wndclass.hInstance      = hInstance;
         wndclass.hIcon          = NULL; /*LoadIcon (NULL, IDI_ASTERISK);*/
         wndclass.hCursor        = LoadCursor (NULL, IDC_CROSS);
         wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
         wndclass.lpszMenuName   = szAppName;
         wndclass.lpszClassName  = szAppName;

         if (!RegisterClass (&wndclass) )
             return FALSE;
     }


     hWnd = CreateWindow (szAppName, "Rect",
       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
       CW_USEDEFAULT, 0, NULL, NULL,
       hInstance, NULL);

     hInstMain = hInstance;
     hWndMain  = hWnd;

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

     lpProcEnterPoint    = MakeProcInstance (EnterPointDlgProc, hInstance);
     lpProcNewEnterPoint = MakeProcInstance (NewEnterPointDlgProc,hInstance);

     while (GetMessage (&msg, NULL, 0, 0))  {
        TranslateMessage (&msg);
        DispatchMessage (&msg);
     }
     return msg.wParam;
 }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
   HWND      hWnd;
   unsigned    iMessage;
   WORD      wParam;
   LONG      lParam;
   {
    HMENU         hMenu;
 static   RECT    Rect1, Rect2, Rect3;
   static short  xClient, yClient;
   HDC          hDC;
   PAINTSTRUCT   ps;
    int           xOffset, yOffset;

   switch (iMessage) {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             SetRectEmpty (&Rect1);
             SetRectEmpty (&Rect2);
             SetRectEmpty (&Rect3);

             Rect1.top = 50;
             Rect1.left = 150;
             Rect1.right = 250;
             Rect1.bottom = 110;

             Rect2.top = 160;
             Rect2.left = 400;
             Rect2.right = 500;
             Rect2.bottom = 220;
             UnionRect (&Rect3, &Rect2, &Rect1);
             break;

        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
             break;

       case WM_SIZE:
             xClient=LOWORD (lParam);
             yClient=HIWORD (lParam);
             break;


        case WM_COMMAND:
             switch (wParam) {
                case IDM_CHANGERECT1:
                     SetRectEmpty (&Rect1);
                     MessageBox (hWnd, "Rectangle 1 has been emptied",
                                 "SetRectEmpty", MB_OK);
                     sprintf (szYValue, "Enter Coordinates");
                     sprintf (szXValue, "rect1.top,  rect1.left");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     Rect1.top  = atoi (szXValue);
                     Rect1.left = atoi (szYValue);

                     sprintf (szYValue, "Enter Coordinates");
                     sprintf (szXValue, "rect1.bottom, rect1.right");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     Rect1.bottom = atoi (szXValue);
                     Rect1.right  = atoi (szYValue);

                     UnionRect (&Rect3, &Rect2, &Rect1);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_CHANGERECT2:
                     SetRectEmpty (&Rect2);
                     MessageBox (hWnd, "Rectangle 2 has been emptied",
                                 "SetRectEmpty", MB_OK);
                     sprintf (szYValue, "Enter Coordinates");
                     sprintf (szXValue, "rect2.top,  rect2.left");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     Rect2.top  = atoi (szXValue);
                     Rect2.left = atoi (szYValue);

                     sprintf (szYValue, "Enter Coordinates");
                     sprintf (szXValue, "rect2.bottom, rect2.right");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     Rect2.bottom = atoi (szXValue);
                     Rect2.right  = atoi (szYValue);

                     UnionRect (&Rect3, &Rect2, &Rect1);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_OFFSETRECT1:
                     sprintf (szYValue, "Enter Offsets");
                     sprintf (szXValue, "X Offset, Y Offset");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     xOffset = atoi (szXValue);
                     yOffset = atoi (szYValue);

                     OffsetRect (&Rect1, xOffset, yOffset);
                     UnionRect (&Rect3, &Rect2, &Rect1);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_OFFSETRECT2:
                     sprintf (szYValue, "Enter Offsets");
                     sprintf (szXValue, "X Offset, Y Offset");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     xOffset = atoi (szXValue);
                     yOffset = atoi (szYValue);

                     OffsetRect (&Rect2, xOffset, yOffset);
                     UnionRect (&Rect3, &Rect2, &Rect1);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_HELP:
                     ProcessMessage (hWnd, 2);
                     break;
             }
             break;

       case WM_PAINT:
             hDC=BeginPaint(hWnd, &ps);
             DrawSquare (hDC, Rect1);
             DrawSquare (hDC, Rect2);
             DrawSquare (hDC, Rect3);

             EndPaint (hWnd, &ps);
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }

 /***************************************************************************/

 BOOL FAR PASCAL GetRadiusDlgProc (hDlg, iMessage, wParam, lParam)
 HWND hDlg;
 unsigned iMessage;
 WORD wParam;
 LONG lParam;
 {
      int Index;
      char szChange [10];
      long lReturn;

      switch (iMessage) {
         case WM_INITDIALOG:
              SendDlgItemMessage (hDlg, IDD_RADIUS, EM_LIMITTEXT,
                                  (WORD)80, 0L);
              SetDlgItemText (hDlg, IDD_RADIUS, "1.0");
              return TRUE;
              break;

         case WM_COMMAND:
              switch (wParam)
              {
                case IDD_RADIUS:
                     if (HIWORD (lParam) == EN_CHANGE)
                         EnableWindow (GetDlgItem(hDlg,IDOK),
                                      (BOOL)SendMessage(LOWORD (lParam),
                                       WM_GETTEXTLENGTH, 0, 0L)) ;
                     break;

                case IDOK:
                     GetDlgItemText (hDlg, IDD_RADIUS, szRadius, 80) ;
                     OemToAnsi (szRadius, szRadius);
                     EndDialog (hDlg, TRUE);
                     break;

                case IDCANCEL:
                 EndDialog (hDlg, FALSE) ;
                     break;

                default:
                     return FALSE;
              }
         default:
              return FALSE;
      }
      return TRUE;
 }

 /****************************************************************************

 BOOL FAR PASCAL EnterPointDlgProc (hDlg, iMessage, wParam, lParam)
 HWND hDlg;
 unsigned iMessage;
 WORD wParam;
 LONG lParam;
 {
      int Index;
      char szChange [10];
      long lReturn;

      switch (iMessage) {
      case WM_INITDIALOG:
        SendDlgItemMessage (hDlg, IDD_X, EM_LIMITTEXT,
                            (WORD)40, 0L);
        SendDlgItemMessage (hDlg, IDD_Y, EM_LIMITTEXT,
                            (WORD)40, 0L);
        SetDlgItemText (hDlg, IDD_TEXT1, szXValue);
        SetDlgItemText (hDlg, IDD_TEXT2, szYValue);

        hX = GetDlgItem (hDlg, IDD_X);
          lpProcOldX = (FARPROC) GetWindowLong (hX, GWL_WNDPROC);
          SetWindowLong (hX, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hX, EM_SETSEL, 0, MAKELONG (0,32767));
        hY = GetDlgItem (hDlg, IDD_Y);
          lpProcOldY = (FARPROC) GetWindowLong (hY, GWL_WNDPROC);
          SetWindowLong (hY, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hY, EM_SETSEL, 0, MAKELONG (0,32767));
        hOK2 = GetDlgItem (hDlg, IDOK);

        return TRUE;
        break;

      case WM_COMMAND:
        switch (wParam) {
          case IDD_X:
               break;

          case IDD_Y:
               break;

          case IDOK:
               GetDlgItemText (hDlg, IDD_X, szXValue, 10) ;
               GetDlgItemText (hDlg, IDD_Y, szYValue, 10) ;
               EndDialog (hDlg, TRUE);
               break;

          default:
               return FALSE;
       }
     default:
       return FALSE;
   }
   return TRUE;
 }

 /****************************************************************************

 BOOL FAR PASCAL NewEnterPointDlgProc  (hWnd, iMessage, wParam, lParam)
      HWND     hWnd;
      unsigned iMessage;
      WORD     wParam;
      LONG     lParam;
 {
      switch (iMessage) {
        case WM_GETDLGCODE:
             return (DLGC_WANTALLKEYS);

        case WM_CHAR:
             if ((wParam == VK_TAB) || (wParam == VK_RETURN)) {
                 SendMessage (hWndMain, WM_USER, 0, 0L);
                 SetFocus (FindNextWindow (hWnd));
                 return TRUE;
             }
             else {
               if (hWnd == hX)
                 return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                         iMessage, wParam, lParam));
               if (hWnd == hY)
                 return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                         iMessage, wParam, lParam));
             }
             break;

        default:
          if (hWnd == hX)
             return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                     iMessage, wParam, lParam));
          if (hWnd == hY)
             return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                     iMessage, wParam, lParam));
      }
 }

 /****************************************************************************

 HWND FindNextWindow (hWnd)
      HWND   hWnd;
 {
      if (hWnd == hX)      return hY;
      if (hWnd == hY)      return hOK2;
      return NULL;
 }

 /****************************************************************************

 void DrawSquare (hDC, rect)
      HDC       hDC;
      RECT      rect;
 {
      MoveTo (hDC, rect.left,  rect.top);
      LineTo (hDC, rect.right, rect.top);
      LineTo (hDC, rect.right, rect.bottom);
      LineTo (hDC, rect.left,  rect.bottom);
      LineTo (hDC, rect.left,  rect.top);
 }



 RELABS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\RELABS.C

 /*

 Description:

 This program first invokes the function GetRelAbs to find and display
 the current mode.  The mode is set to another value using the SetRelAbs
 function. GetRelAbs is called again to verify that the mode has indeed
 changed.  Below are descriptions for the demonstrated functions.

 SetRelAbs sets the relative or absolute mode. This function specifies
 whether the coordinates in GDI functions are relative to the origin
 of the given device (ABSOLUTE), or relative to the current position
 (RELATIVE).  The mode affects the output created by the LineTo and
 Polyline functions.

 GetRelAbs retrieves the relative-absolute flag. The return value
 specifies the current mode.  It can be ABSOLUTE or RELATIVE.

 ****************************************************************************/

 #include <windows.h>
 #include <string.h>

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "GetRelAbs" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "GetRelAbs",  /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  PAINTSTRUCT     ps;
  short           fRelAbsFlag;
  HDC             hDC;
  TEXTMETRIC      tm;
  static short    xChar,
                  yChar;

  switch(iMessage)
  {
   case WM_CREATE:
   {
    hDC = GetDC (hWnd);
    GetTextMetrics (hDC, &tm);
    xChar = tm.tmAveCharWidth;
    yChar = tm.tmHeight + tm.tmExternalLeading;
    ReleaseDC (hWnd, hDC);
    break;
   }
   case WM_PAINT:
   {
    hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);

    fRelAbsFlag = GetRelAbs (hDC);                        /* Check the mode */

    if (fRelAbsFlag == RELATIVE)
       {
       TextOut (hDC,
                xChar,
                yChar,
                (LPSTR)"1. Function GetRelAbs returns RELATIVE, so the mode is
                strlen("1. Function GetRelAbs returns RELATIVE, so the mode is
               );

       SetRelAbs (hDC, ABSOLUTE);
       }
    else /* fRelAbsFlag ==  ABSOLUTE */         /* Set the mode to ABSOLUTE */
       {
       TextOut (hDC,
                xChar,
                yChar,
                (LPSTR)"1. Function GetRelAbs returns ABSOLUTE, so the mode is
                strlen("1. Function GetRelAbs returns ABSOLUTE, so the mode is
               );

       SetRelAbs (hDC, RELATIVE);               /* Set the mode to RELATIVE */
       }

    fRelAbsFlag = GetRelAbs (hDC);                        /* Check the mode */

    if (fRelAbsFlag == RELATIVE)
       {
       TextOut (hDC,
                xChar,
                yChar * 2,
                (LPSTR)"2. Function SetRelAbs sets mode to RELATIVE.  Function
                strlen("2. Function SetRelAbs sets mode to RELATIVE.  Function
               );
       }
    else /* fRelAbsFlag ==  ABSOLUTE */
       {
       TextOut (hDC,
                xChar,
                yChar * 2,
                (LPSTR)"2. Function SetRelAbs sets mode to ABSOLUTE.  Function
                strlen("2. Function SetRelAbs sets mode to ABSOLUTE.  Function
               );
       }


    EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 REPLY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\REPLY.C

 /*

 Description:   This function specifies whether the current window function
     is processing a message that is passed to it through a call to the
     SendMessage function.

 */


 #include <windows.h>
 #include "Reply.h"
 #include "string.h"
 #include "stdio.h"

        char         szAppName             [] = "Reply"             ;
        HANDLE       hInstMain                                      ;
        HWND         hWndMain                                       ;
        char         szOutputBuffer1       [70]                     ;
        char         szOutputBuffer2       [600]                    ;

 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use  of  the  ReplyMessage Windows function.  ",

 "Help Message",
 "     Sample program to illustrate the use of ReplyMessage.\n\
 Use the WINSPAWN program to spawn this program in one of\n\
 two ways.  The first way, 'Reply Using ReplyMessage',\n\
 will capture the input focus using the ReplyMessage\n\
 Windows Function.   The second way, 'Reply Regular Spawn',\n\
 will not capture the focus.",

 "In Reply",
 "     Message sent and received from within Reply.\n\
 The Reply program has successfully captured the input\n\
 focus."

 };
 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;
     HMENU  hMenu;
     short   xScreen, yScreen;


     if (!hPrevInstance)
   {
   wndclass.style           = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
   wndclass.lpfnWndProc    = WndProc;
   wndclass.cbClsExtra     = 0;
   wndclass.cbWndExtra     = 0;
   wndclass.hInstance      = hInstance;
   wndclass.hIcon           = NULL;
    wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = szAppName;
   wndclass.lpszClassName  = szAppName;

     if (!RegisterClass (&wndclass) )
         return FALSE;
     }

    xScreen = GetSystemMetrics (SM_CXSCREEN);
     yScreen = GetSystemMetrics (SM_CYSCREEN);

     hWnd = CreateWindow (szAppName, "Reply",
            WS_OVERLAPPEDWINDOW, xScreen / 7, yScreen / 58,
            xScreen * 3 / 4, yScreen * 49 / 50, NULL, NULL,
            hInstance, NULL);

     hInstMain = hInstance;
     hWndMain  = hWnd;

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

     while (GetMessage (&msg, NULL, 0, 0))
         {
         TranslateMessage (&msg);
         DispatchMessage (&msg);
         }

     return msg.wParam;
 }
 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
    HWND      hWnd;
    unsigned  iMessage;
    WORD      wParam;
    LONG      lParam;
    {
    HMENU         hMenu;
    int           Index;
    HANDLE        hDC;
    HDC           hMemoryDC;
    BITMAP        Bitmap;
   short         foo;
    BOOL          InSend;

    switch (iMessage)
        {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             break;

        case WM_SIZE:
             break;

        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
        break;


        case WM_COMMAND:
             switch (wParam) {
               case IDM_RECEIVE:
                    ProcessMessage (hWnd, 4);
                    break;

               case IDM_SEND:
                    ReplyMessage (1L);
                    SendMessage (hWnd, WM_COMMAND, IDM_RECEIVE, 0L);
                    break;

               case IDM_REGULAR:
                    break;

               case IDM_HELP:
                    ProcessMessage (hWnd, 2);
                    break;
            }
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }

 /****************************************************************************



 RRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\RRECT.C

 /*
  *  RoundRect
  *
  *  This program demonstrates the use of the function RoundRect.
  *  It gets a DC and then draws a rectangle with rounded corners in the
  *  client area.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Rrect";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;             /* Handle to the parent window    */
     BOOL  bRect;            /* flag for RoundRect routine     */
     HDC   hDC;              /* display context of client area */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Rrect",
                         (LPSTR)"Drawing Round Rectangle",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* draw the round rectangle on the client area */
     hDC = GetDC (hWnd);
     bRect = RoundRect (hDC, 50, 50, 175, 150, 25, 20);
     ReleaseDC (hWnd, hDC);

     /* return code for RoundRect routine */
     if (bRect)
       {  MessageBox (hWnd, (LPSTR)"The rectangle is drawn",
                      (LPSTR)"Done", MB_OK);
       }
     else
       {  MessageBox (hWnd, (LPSTR)"The rectangle is not drawn",
                      (LPSTR)NULL, MB_OK);
       }

     return 0;
 }



 SAVEDC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DISPLAY\SAVEDC.C

 /*
  *  SaveDC
  *  savedc.c,
  *
  *  This program demonstrates the use of the function SaveDC.
  *  It saves the current state of the display context by copying state
  *  information to a context stack. The saved display context can later
  *  be restored by using the RestoreDC function.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Savedc";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND   hWnd;                /* Handle to the parent window    */
     HDC    hDC;                 /* Display context of client area */
     HBRUSH hNewBrush, hOldBrush;/* Handle to the brushes          */
     short  nDCIdentity;         /* identifier to the saved DC     */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Savedc",
                         (LPSTR)"Saving Display Context",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Get the DC of the client area */
     hDC = GetDC (hWnd);

     /* Create a new brush and change the DC */
     hNewBrush = CreateSolidBrush (GetSysColor (COLOR_WINDOW));
     hOldBrush = (HBRUSH) SelectObject (hDC, (HANDLE) hNewBrush);

     /* Save the DC and get an unique identity of the saved DC */
     nDCIdentity = SaveDC (hDC);

     /* Release the DC */
     ReleaseDC (hWnd, hDC);

     /* return code for SaveDC routine. It is 0 if the DC is not saved */
     if (nDCIdentity)
       {  MessageBox (hWnd, (LPSTR)"The DC is saved",
                      (LPSTR)"Done", MB_OK);
       }
     else
       {  MessageBox (hWnd, (LPSTR)"The DC is not saved",
                      (LPSTR)NULL, MB_OK);
       }

     return 0;
 }


 SBITDIM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SBITDIM.C

 /*
  *  SetBitmapDimension
  *  sbitdim.c,
  *
  *  This program demonstrates the use of the function SetBitmapDimension.
  *  This funtion assigns a width and height to a bitmap in 0.1 millimeters
  *  units.  These values are not used internally by GDI.
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HBITMAP hBitmap;
   DWORD ptOldDimensions;
   DWORD ptDimensions;

   hBitmap = LoadBitmap ( hInstance, (LPSTR)"SMILE" );

   MessageBox (NULL, (LPSTR)"Setting new dimensions ",
              (LPSTR)"SetBitmapDimension", MB_OK);

   ptOldDimensions = SetBitmapDimension ( hBitmap, 15, 15 );

   ptDimensions = GetBitmapDimension ( hBitmap );

   if ( (HIWORD(ptDimensions) != 0) || (LOWORD(ptDimensions) != 0) )
      MessageBox (NULL, (LPSTR)"New dimensions set.",
                 (LPSTR)"SetBitmapDimension", MB_OK);
   else
      MessageBox (NULL, (LPSTR)"New dimensions not set",
                 (LPSTR)"SetBitmapDimension", MB_OK);

   return 0;
 }


 SCEM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\SCEM.C

 /*
  *
  *  SetCommEventMask
  *
  *  This program demonstrates the use of the function SetCommEventMask.
  *  This function enables and retrieves the event mask of the communication
  *  device specified bye the first parameter.
  *
  *  Microsoft Product Support Services
  *  Windows Version 2.0 function demonstration application
  *
  */

 #include <windows.h>

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   int nCid;
   WORD lpEvent;
   char szBuffer [70];

   nCid = OpenComm ( (LPSTR)"COM1", 50, 50);
   if ( nCid < 0 )
      {
      MessageBox (NULL, (LPSTR)"OpenComm Failed", (LPSTR)"OpenComm",
         MB_OK|MB_ICONEXCLAMATION);
      exit (1);
      }
   MessageBox (NULL, (LPSTR)"Setting EV_ERR mask", (LPSTR)"SetCommEventMask",
      MB_OK);

   SetCommEventMask ( nCid, EV_ERR );

   GetCommEventMask ( nCid, EV_ERR );
   WriteComm ( nCid, (LPSTR)"This is a test!!!", 25 );

   lpEvent = SetCommEventMask( nCid, EV_ERR );
   sprintf (szBuffer, "Pointer to the event mask is %x", lpEvent);

   MessageBox (NULL, (LPSTR)szBuffer, (LPSTR)"SetCommEventMask",
               MB_OK);

   CloseComm ( nCid );

   return 0;
 }


 SCNTOCLI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLIENT\SCNTOCLI.C

 /*
  *  ScreenToClient
  *  scntocli.c,
  *
  *  This program demonstrates the use of the function ScreenToClient.
  *  It converts the screen coordinates of the point into equivalent client
  *  coordinates. The new coordinates replace the existing point.
  *
  */

 #include "windows.h"
 #include <stdio.h>

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Scntocli";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND   hWnd;                /* Handle to the parent window    */
     POINT  ptCurrentPoint;      /* POINT data type                */
     char   szBuffer[60];        /* string buffer for output       */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Scntocli",
                         (LPSTR)"Screen/Client Coordinates",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Initializing the point to some screen coordinate and display the
      * value in a message box
      */
     ptCurrentPoint.x = 234;
     ptCurrentPoint.y = 150;
     sprintf (szBuffer, "The screen coordinates of the point is %d and %d",
              ptCurrentPoint.x, ptCurrentPoint.y);
     MessageBox (hWnd, (LPSTR)szBuffer, (LPSTR)"Screen", MB_OK);

     /* convert the point to client coordinate and display the new value
      * in a message box
      */
     ScreenToClient (hWnd, (POINT FAR *) &ptCurrentPoint);
     sprintf (szBuffer, "The client coordinates of the point is %d and %d",
              ptCurrentPoint.x, ptCurrentPoint.y);
     MessageBox (hWnd, (LPSTR)szBuffer, (LPSTR)"Client", MB_OK);

     return 0;
 }


 SCRDC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SCRDC.C

 /*
 Function(s) demonstrated in this program: ScrollDC
 Compiler version: C 5.1
 Description:
 */

 #include <windows.h>
 #include "scrdc.h"

 static char szFuncName [] = "ScrollDC";
 static char szAppName [] = "SCRDC";

 int PASCAL WinMain ( hInstance, hPrevInstance, lpszCmdLine, nCmdShow )
 HANDLE      hInstance, hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
 {
      HWND        hWnd;
      WNDCLASS    wndclass;
      MSG         msg;
      HMENU       hMenu;

      if (!hPrevInstance) {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW;
           wndclass.lpfnWndProc   = WndProc;
           wndclass.cbClsExtra    = 0;
           wndclass.cbWndExtra    = 0;
           wndclass.hInstance     = hInstance;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
           wndclass.lpszMenuName  = "SCR";
           wndclass.lpszClassName = szFuncName;

           if (!RegisterClass (&wndclass))
                return FALSE;
           }

      hMenu = LoadMenu ( hInstance, "SCR" );


      hWnd = CreateWindow (szFuncName,           /* window class name       */
                     szAppName,                  /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     hMenu,                      /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL);                      /* create parameters       */

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

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam);
 }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
    HDC         hDC;
    PAINTSTRUCT ps;
    RECT        strRectangle;
    RECT        strClipRectangle;
    RECT        strDirtyRectangle;
    HBRUSH      hSolidBrush;
    BOOL        bfScrolled;
    int         nIndex;

    switch(iMessage)
    {
    case WM_INITMENU:
       InvalidateRect ( hWnd, (LPRECT)NULL, TRUE );
       break;
     case WM_COMMAND:
        switch ( wParam )
           {
           case IDM_BOX:
              strRectangle.top = 0;
              strRectangle.bottom = 100;
              strRectangle.left = 0;
              strRectangle.right = 100;
              strClipRectangle.top = 0;
              strClipRectangle.bottom = 100;
              strClipRectangle.left = 0;
              strClipRectangle.right = 250;

              hDC = GetDC ( hWnd );
              hSolidBrush = CreateSolidBrush ( 0xFF0000 );
              FillRect ( hDC, (LPRECT)&strRectangle, hSolidBrush );

              MessageBox ( hWnd, (LPSTR)"Going to scroll the DC.",
                 (LPSTR)szFuncName, MB_OK );

              bfScrolled = ScrollDC ( hDC, 110, 0, (LPRECT)&strRectangle,
                 (LPRECT)&strClipRectangle, NULL, (LPRECT)&strDirtyRectangle )

              if ( bfScrolled == TRUE )
                 {
                 MessageBox ( hWnd, (LPSTR)"Going to invalidate the box.",
                    (LPSTR)szFuncName, MB_OK );
                 InvalidateRect ( hWnd, (LPRECT)&strRectangle, TRUE );
                 }
              else
                 MessageBox ( hWnd, (LPSTR)"Could not scroll the DC.",
                    (LPSTR)szFuncName, MB_OK | MB_ICONHAND );

              ReleaseDC ( hWnd, hDC );

              break;
           default :
              break;
           }
        break;
      case WM_DESTROY:
        PostQuitMessage(0);
        break;
      default:
        return DefWindowProc (hWnd, iMessage, wParam, lParam);
      return (0L);
    }
 }


 SCROLL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SCROLL.C

 /* SCROLL.C               */
 /* This program illistrates the use of ScrollDC and ScrollWindow */
 /* as well as many other Windows functions. ScrollDC is used to  */
 /* "Bounce" individual balls, one at a time, from the top of the */
 /* display to the bottom of the display. ScrollWindow is used to */
 /* "Raise" all the balls from the bottom of the display to the   */
 /* top of the display. This program gets the resolution of the   */
 /* screen to determine what would be a good shape for the ball   */
 /* as well as to deternime how fast to scroll the ball. We also  */
 /* get the size of the client area so that we can deternime how  */
 /* many balls to draw on the screen. I decided the height of the */
 /* ball should be 1/10 the height of the client area and the it  */
 /* should be drawn 1/10 of the way down the client area and the  */
 /* same distance over on the client area. The other balls are   */
 /* drawn similarly. Enjoy .....................................  */

 #include <windows.h>
 #include "scroll.h"


 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 static char szAppName [] = "Scroll" ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {

      HWND        hWnd ;
      MSG         msg ;
      WNDCLASS   wndclass ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
     wndclass.hIcon   = LoadIcon (hInstance, szAppName) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = szAppName;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,       /* window class    */
         "Scroll",   /* window caption      */
                     WS_OVERLAPPEDWINDOW,     /* window style            */
                     CW_USEDEFAULT,           /* initial x position      */
                     0,                       /* initial y position      */
                     CW_USEDEFAULT,           /* initial x size          */
                     0,                       /* initial y size          */
                     NULL,                    /* parent window handle    */
                     NULL,                    /* window menu handle      */
                     hInstance,               /* program instance handle */
                     NULL) ;                  /* create parameters       */

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

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 void FAR PASCAL StopOne(){
     return;
     }


 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
      HWND      hWnd ;
      unsigned      iMessage ;
      WORD      wParam ;
      LONG      lParam ;
      {
      static int   xClient, yClient ;
      static int   xScreen, yScreen ;
      static short   numBalls , bounced ;
      static short   ScrollRate ;
      HDC      hDC ;
      PAINTSTRUCT    ps ;
      RECT      ClientRect ;
      RECT      DcRect ;
      RECT      Ball ;
      RECT      NewBall ;
      RECT      ScrollBox ;
      short      i, j, up, down ;
      char szBuffer[80] ;

      switch (iMessage)
     {
     case WM_CREATE:

 /* Get the resolution of the Screen */

          xScreen = GetSystemMetrics (SM_CXSCREEN) ;
          yScreen = GetSystemMetrics (SM_CYSCREEN) ;

 /* Get the size of the client area initially */

          GetClientRect (hWnd, &ClientRect) ;

 /* and save it in static variables */

          yClient = ClientRect.bottom - ClientRect.top ;
          xClient = ClientRect.right - ClientRect.left  ;

 /* Set scroll speed for different resolutions */

          if (yClient <= 50) ScrollRate = 1 ;
          if (yClient > 100)  ScrollRate = 3 ;
          if (yClient > 175)  ScrollRate = 5 ;

          break ;


     case WM_SIZE:

 /* Update the size of the client area */

          yClient = HIWORD (lParam) ;
          xClient = LOWORD (lParam) ;

 /* Set scroll speed for different resolutions */

          if (yClient <= 50) ScrollRate = 1 ;
          if (yClient > 100)  ScrollRate = 3 ;
          if (yClient > 175)  ScrollRate = 5 ;

          break ;


          break ;

     case WM_PAINT:

 /* Begin to paint the client area and redraw the balls */

          BeginPaint (hWnd, &ps);

 /* Initialize the size of the ball */

          Ball.top    = ( yClient / 10) ;
          Ball.bottom = ( yClient / 5) ;
          Ball.left   = ((Ball.bottom - Ball.top) * (xScreen / yScreen)) ;
          Ball.right  = 2 * Ball.left ;

 /* Determine the number of balls that can fit on the screen */

          numBalls = ( xClient - (Ball.right - Ball.left) ) /
             ( 2 * (Ball.right - Ball.left)) ;

 /* And use this as a standard for drawing the balls */

          NewBall = Ball ;

          for (i = 0 ; i < numBalls; i ++ ) {

      Ellipse (ps.hdc, NewBall.left, NewBall.top,
         NewBall.right, NewBall.bottom);

 /* Update the position of the new ball */

      NewBall.left = NewBall.left +  2 * (Ball.right - Ball.left);
      NewBall.right = NewBall.right + 2 * (Ball.right - Ball.left);

          }

          EndPaint (hWnd, &ps);

 /* Set bounced to false, signifing that the balls are on the
       top of the display */

          bounced = 0 ;

          break ;

     case WM_COMMAND:

          switch (wParam)
          {
          case IDM_DC:

         if (!bounced) {

 /* Initialize the size of the ball */

            Ball.top   = ( yClient / 10) ;
            Ball.bottom = ( yClient / 5) ;
            Ball.left   = ((Ball.bottom - Ball.top) * (xScreen / yScreen)) ;
            Ball.right  = 2 * Ball.left ;

 /* Initialize the scrolling area for one ball */

            ScrollBox.top = 1 ;
            ScrollBox.left = Ball.left / 2 ;
            ScrollBox.bottom = yClient ;
            ScrollBox.right = ScrollBox.left + (2 * Ball.left) ;

            hDC = GetDC (hWnd) ;
            for (i = 0 ; i < numBalls; i ++ ) {

              up = Ball.bottom ;
              down = yClient - (2 * ScrollRate) ;

 /* Until the ball is done bouncing */

              while (up < down ) {

 /* It goes down */

          for (j = up ; j <= down ; j += ScrollRate ) {
            ScrollDC (hDC,0, ScrollRate,
                  &ScrollBox,&ScrollBox,
                  NULL,NULL);
          }

 /* and won't go up quit so high */
          up = up + ((down - up) / 3) + 1 ;
            /*  MessageBeep (0); */


 /* and now it bounces up */
          for (j = up ; j <= down ; j += ScrollRate ) {
            ScrollDC (hDC,0, - ScrollRate,
                  &ScrollBox,&ScrollBox,
                  NULL,NULL);
          }
              }

 /* and bounces down for the last time */

              for (j = up ; j <= down ; j += ScrollRate ) {
          ScrollDC (hDC,0, 1,&ScrollBox,&ScrollBox,
                NULL,NULL);
              }

 /* Move to the next scrolling area */

              ScrollBox.left = ScrollBox.left + ( 2 * Ball.left) ;
              ScrollBox.right = ScrollBox.right + (2 * Ball.left);
            }

            ReleaseDC (hWnd, hDC) ;
            bounced = 1 ;
         }

         break ;

          case IDM_WIN:

 /* If the balls are at the bottom of the display then */

         if (bounced) {

 /* Initialize how far they need to rise */

           down = yClient - (2 * ScrollRate);
           up = (yClient / 5) ;

 /* And raise them to the top */

           for (j = up ; j <= down ; j += ScrollRate ) {
             ScrollWindow (hWnd, 0,- ScrollRate,
                  NULL, NULL) ;
           }

           MessageBeep (0);

 /* Set bounced to false, signifing the balls are at the top of the display */

           bounced = 0 ;

         }

         break ;

          case IDM_EXIT:

         SendMessage (hWnd, WM_CLOSE, 0, 0L);
         break;

          case IDM_HELP:

         MessageBox (hWnd, "Try Scrolling the DC ...",
              szAppName, MB_ICONASTERISK | MB_OK) ;
         break;
          case IDM_ABOUT:

         MessageBox (hWnd, "SCROLL DEMO.",
              szAppName, MB_ICONASTERISK | MB_OK) ;
          default:
         break;
          }
          break;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                break ;

           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
           }
      return 0L ;
      }



 SCRPAT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SCRPAT.C

 /*
  *  Function(s) demonstrated in this program: UnrealizeObject, SetBrushOrg,
  *                                            PatBlt
  *  Compiler version: 5.1
  *  Description:
  *     This program will set up a cross hatched pattern on the client
  *  area of a window.  It will then scroll it using the two above functions
  *  in conjunction with timer messages.
  */

 #include <windows.h>

 int     iTimerCount;
 HBRUSH  hNewBrush;
 RECT    rRect;

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int         nCmdShow ;
   {
   static char szAppName [] = "ScrPat" ;
   HWND        hWnd ;
   WNDCLASS    wndclass ;
   MSG msg;
   HDC hDC;

   if (!hPrevInstance)
     {
     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = NULL;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = NULL;
     wndclass.lpszMenuName  = NULL ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
       return FALSE ;
     }

   hWnd = CreateWindow (szAppName,            /* window class name       */
                  "ScrPat Sample Application",  /* window caption          */
                  WS_OVERLAPPEDWINDOW,        /* window style            */
                  CW_USEDEFAULT,              /* initial x position      */
                  0,                          /* initial y position      */
                  CW_USEDEFAULT,              /* initial x size          */
                  0,                          /* initial y size          */
                  NULL,                       /* parent window handle    */
                  NULL,                       /* window menu handle      */
                  hInstance,                  /* program instance handle */
                  NULL) ;                     /* create parameters       */

   /* Set up the background brush. */
   hNewBrush = CreateHatchBrush(HS_DIAGCROSS, RGB(0, 0, 255));
   hDC = GetDC(hWnd);
   GetClientRect( hWnd, (LPRECT) &rRect );
   ReleaseDC(hWnd, hDC);

   /* Start up the timer to roll the pattern. */
   SetTimer(hWnd, 100, 133, 0L);

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

   while (GetMessage(&msg, NULL, 0, 0))
     {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
     }
   return (msg.wParam) ;
   }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
   {
   HDC         hDC;
   HMENU       hMenu;
   PAINTSTRUCT ps;

   switch(iMessage)
     {
     case WM_CREATE:
       break;

     case WM_ERASEBKGND:
         /* Don't let it paint the background. */
         return((long)TRUE);

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );

         SelectObject(ps.hdc, GetStockObject(NULL_BRUSH));
         UnrealizeObject(hNewBrush);
         SetBrushOrg(ps.hdc, 0, iTimerCount);
         SelectObject(ps.hdc, hNewBrush);

         PatBlt(ps.hdc,
                ps.rcPaint.left,
                ps.rcPaint.top,
                ps.rcPaint.right - ps.rcPaint.left,
                ps.rcPaint.bottom - ps.rcPaint.top,
                PATCOPY);

         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_TIMER:
         if (wParam == 100 ) {

             iTimerCount = (iTimerCount+1) % 64;

             hDC = GetDC(hWnd);

             SelectObject(hDC, GetStockObject(NULL_BRUSH));
             UnrealizeObject(hNewBrush);
             SetBrushOrg(hDC, 0, iTimerCount);
             SelectObject(hDC, hNewBrush);

             PatBlt(hDC,
                    rRect.left,
                    rRect.top,
                    rRect.right,
                    rRect.bottom,
                    PATCOPY);

             ReleaseDC(hWnd, hDC);

             break;
             }

     case WM_DESTROY:
       {
       PostQuitMessage(0);
       break;
       }
     default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
     }
     return (0L);
   }


 SECLIPRG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SECLIPRG.C

 /*
  *  Program Name:    secliprg.c
  *
  *  Description:
  *   The program below will create a region and select it as a
  *   clip region in the window.  A (partial) rectangle will be
  *   drawn in the clip region to show where the clipping takes place.
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_SelectClipRgn(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HRGN hNewRgn;
   short nRgnType;

   hNewRgn = CreateRectRgn(50, 50, 200, 100);

   nRgnType = SelectClipRgn(hDC, hNewRgn);      /* region selected     */

   if (nRgnType == 1)                     /* Check for error */
     {
     MessageBox(hWnd,(LPSTR)"SelectClipRgn failed.",(LPSTR)"ERROR",MB_ICONHAND
       return;
     }

   Rectangle( hDC, 60, 60, 220, 80);
   DeleteObject( hNewRgn );

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"SelectClipRgn";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"SelectClipRgn",
                         (LPSTR)"SelectClipRgn()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_SelectClipRgn(hWnd, ps.hdc);
         ValidateRect(hWnd, (LPRECT) NULL);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 SELOBJ.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\OBJECT\SELOBJ.C

 /*
 Function(s) demonstrated in this program: SelectObject
 Compiler version:5.1
 Description: This example creates a object (a pen), selects the object into
              the hDC, and checks the return value.
 */

 #include <windows.h>
 #include "selobj.h"

 static char szAppName [] = "SELOBJ";
 static char szFuncName [] = "SelectObject";

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance;
 HANDLE      hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
 {

    HWND        hWnd;
    WNDCLASS    wndclass;
    MSG         msg;
    HMENU       hMenu;

    if (!hPrevInstance)
       {
       wndclass.style         = CS_HREDRAW | CS_VREDRAW;
       wndclass.lpfnWndProc   = WndProc;
       wndclass.cbClsExtra    = 0;
       wndclass.cbWndExtra    = 0;
       wndclass.hInstance     = hInstance;
       wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
       wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
       wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
       wndclass.lpszMenuName  = (LPSTR)"Select";
       wndclass.lpszClassName = szAppName;

       if (!RegisterClass (&wndclass))
          return FALSE;
       }

    hMenu = LoadMenu ( hInstance, (LPSTR)"Select" );

    hWnd = CreateWindow (szAppName,            /* window class name       */
                   szFuncName,                 /* window caption          */
                   WS_OVERLAPPEDWINDOW,        /* window style            */
                   CW_USEDEFAULT,              /* initial x position      */
                   0,                          /* initial y position      */
                   CW_USEDEFAULT,              /* initial x size          */
                   0,                          /* initial y size          */
                   NULL,                       /* parent window handle    */
                   hMenu,                      /* window menu handle      */
                   hInstance,                  /* program instance handle */
                   NULL);                      /* create parameters       */

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

    while (GetMessage(&msg, NULL, 0, 0))
       {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
       }

    return (msg.wParam);
 }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
    HANDLE   hObject;
    HDC      hDC;
    HPEN     hPen;

    switch(iMessage)
    {
    case WM_COMMAND:
       switch ( wParam )
          {
          case IDM_SELECT:
             hDC = GetDC ( hWnd );
             hPen = CreatePen ( 0, 2, (DWORD)0xFF00FF );
             if ( !hPen )
                {
                MessageBox ( hWnd, (LPSTR)"Pen was not created",
                   (LPSTR)szFuncName, MB_OK );
                return (0L);
                }

             hObject = SelectObject ( hDC, hPen );
             if ( hObject )
                MessageBox ( hWnd, (LPSTR)"The object (a pen) was selected",
                   (LPSTR)szFuncName, MB_OK );
             else
                MessageBox ( hWnd, (LPSTR)"The object (a pen) was not selected
                   (LPSTR)szFuncName, MB_OK );

             DeleteObject ( hObject );
             ReleaseDC ( hWnd, hDC );
             break;

          default:
             return DefWindowProc (hWnd, iMessage, wParam, lParam);
          }
       break;

    case WM_DESTROY:
       PostQuitMessage(0);
       break;

    default:
       return DefWindowProc (hWnd, iMessage, wParam, lParam);
    }
    return (0L);
 }


 SENDDLG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DIALOG\SENDDLG.C

 /*
  *  SendDlgItemMessage
  *  senddlg.c,
  *
  *  This program will open up a Dialog box with an edit conrol. When the
  *  user hits the ADD button, the program will send the LISTBOX a
  *  LB_ADDSTRING message to along with appropriate parameters to add the
  *  string in the edit control to the listbox.
  *
  */

  "windows.h"      /* required for all Windows applications */
  "senddlg.h"      /* specific to this program              */

 HANDLE hInst;             /* current instance                      */

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;         /* current instance             */
 HANDLE hPrevInstance;     /* previous instance            */
 LPSTR lpCmdLine;          /* command line                 */
 int nCmdShow;             /* show-window type (open/icon) */
 {
     HWND hWnd;            /* window handle       */
     MSG msg;              /* message             */
     HANDLE hMenu;         /* Handle to the menu  */

     if (!hPrevInstance)              /* Has application been initialized? */
         if (!SendDlgInit(hInstance))
             return (NULL);           /* Exits if unable to initialize     */

     hInst = hInstance;               /* Saves the current instance        */

     hMenu = LoadMenu( hInst, (LPSTR)"SendDlgMenu" );
                                      /*  Load the menu    */

     hWnd = CreateWindow("SendDlg",   /* window class      */
         "SendDlg Sample Application",  /* window name       */
         WS_OVERLAPPEDWINDOW,         /* window style      */
         CW_USEDEFAULT,               /* x position        */
         CW_USEDEFAULT,               /* y position        */
         CW_USEDEFAULT,               /* width             */
         CW_USEDEFAULT,               /* height            */
         NULL,                        /* parent handle     */
         hMenu,                       /* menu or child ID  */
         hInstance,                   /* instance          */
         NULL);                       /* additional info   */

     if (!hWnd)                       /* Was the window created? */
         return (NULL);

     ShowWindow(hWnd, nCmdShow);      /* Shows the window        */
     UpdateWindow(hWnd);              /* Sends WM_PAINT message  */

     while (GetMessage(&msg,     /* message structure                      */
             NULL,               /* handle of window receiving the message */
             NULL,               /* lowest message to examine              */
             NULL))              /* highest message to examine             */
         {
         TranslateMessage(&msg);  /* Translates virtual key codes           */
         DispatchMessage(&msg);   /* Dispatches message to window           */
     }
     return (msg.wParam);         /* Returns the value from PostQuitMessage */
 }

 BOOL SendDlgInit(hInstance)
 HANDLE hInstance;                /* current instance           */
 {
     HANDLE hMemory;              /* handle to allocated memory */
     PWNDCLASS pWndClass;         /* structure pointer          */
     BOOL bSuccess;               /* RegisterClass() result     */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = SendDlgWndProc;
     pWndClass->hInstance = hInstance;
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->lpszMenuName = (LPSTR) "SendDlgMenu";
     pWndClass->lpszClassName = (LPSTR) "SendDlg";

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);     /* Unlocks the memory    */
     LocalFree(hMemory);       /* Returns it to Windows */

     return (bSuccess);        /* Returns result of registering the window */
 }

 long FAR PASCAL SendDlgWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                    /* window handle                   */
 unsigned message;             /* type of message                 */
 WORD wParam;                  /* additional information          */
 LONG lParam;                  /* additional information          */
 {
     FARPROC lpProcAbout;      /* pointer to the "About" function */
     HMENU hMenu;              /* handle to the System menu       */

     switch (message) {
         case WM_SYSCOMMAND:   /* message: command from system menu */
             if (wParam == ID_ABOUT) {
                 lpProcAbout = MakeProcInstance(About, hInst);

                 DialogBox(hInst,         /* current instance         */
                     "AboutBox",          /* resource to use          */
                     hWnd,                /* parent handle            */
                     lpProcAbout);        /* About() instance address */

                 FreeProcInstance(lpProcAbout);
                 break;
             }

             else                         /* Lets Windows process it       */
                 return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CREATE:                  /* message: window being created */

             /* Get the handle of the System menu */

             hMenu = GetSystemMenu(hWnd, FALSE);

             /* Add a separator to the menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 NULL,                            /* new menu item       */
                 NULL,                            /* menu identifier     */
                 MF_APPEND | MF_SEPARATOR);       /* type of change      */

             /* Add new menu item to the System menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 "A&bout SendDlg...",             /* new menu item       */
                 ID_ABOUT,                        /* menu identifier     */
                 MF_APPEND | MF_STRING);          /* type of change      */
             break;

         case WM_COMMAND:
             if ( wParam == IDM_DIALOG )
               {
               FARPROC    lpProcLineList;

               lpProcLineList = MakeProcInstance( LineList, hInst );

               DialogBox( hInst,             /*  Current Instance  */
                          "ListIn",          /*  Resource to use  */
                          hWnd,              /*  Parent Handle  */
                          lpProcLineList );
               FreeProcInstance( lpProcLineList );
               break;
               }

         case WM_DESTROY:             /* message: window being destroyed */
             PostQuitMessage(0);
             break;

         default:                     /* Passes it on if unproccessed    */
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:              /* message: initialize dialog box */
             return (TRUE);

         case WM_COMMAND:                 /* message: received a command */
             if (wParam == IDOK) {        /* "OK" box selected?          */
                 EndDialog(hDlg, NULL);   /* Exits the dialog box        */
                 return (TRUE);
             }
             break;
     }
     return (FALSE);                      /* Didn't process a message    */
 }

 BOOL FAR PASCAL LineList(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     char  szBuffer[ 50 ];    /*  Buffer to hold text from edit control  */

     switch (message) {
         case WM_INITDIALOG:              /* message: initialize dialog box */
             return (TRUE);

         case WM_COMMAND:                 /* message: received a command */
             if (wParam == ID_ADD )       /* "ADD" box selected?         */
               {
               GetDlgItemText( hDlg,      /*  Handle to the dialog box  */
                               ID_EDIT,   /*  ID of item to get text from  */
                               (LPSTR)szBuffer,  /*  Pointer to buffer  */
                               50 );      /*  Maximum size of buffer  */
               SendDlgItemMessage( hDlg,  /*  Handle to the dialog box  */
                                   ID_LISTBOX,  /*  ID for item to send the
                                                 *  message to  */
                                   LB_ADDSTRING,  /*  Message to send  */
                                   0,     /*  The wParam parameter  */
                                   (LONG)(LPSTR)szBuffer );  /*  lParam  */
               SetDlgItemText( hDlg,         /*  Handle to the dialog box  */
                               ID_EDIT,      /*  ID for the edit control  */
                               (LPSTR)"" );  /*  Text to put in edit control *
               SetFocus( GetDlgItem( hDlg, ID_EDIT ) );
                              /*  Give the focus to the edit control  */
 /*  The SendDlgItemMessage sends a message to the Listbox to add the
  *  string to the listbox.  After that we set the text in the edit control
  *  to an empty string, effectively clearing the edit control.  Then
  *  finally we set the focus to the edit control.  */

               return (TRUE);      /*  We processed a message  */
               }
             if ( wParam == ID_OK )
               {
               EndDialog(hDlg, NULL);   /* Exits the dialog box        */
               return (TRUE);
               }
             if ( wParam == ID_CANCEL )
               {
               EndDialog(hDlg, NULL);   /* Exits the dialog box        */
               return (TRUE);
               }
             break;

     }
     return (FALSE);                      /* Didn't process a message    */
 }


 SENDMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\SENDMSG.C

 /*
  *  SendMessage
  *  sendmsg.c,
  *
  *  This program demonstrates the use of the function SendMessage.
  *  It sends a message to the specified window immediately without
  *  putting the message in the application queue. SendMessage does not
  *  return until the message has been processed. The window function
  *  is called immediately, as a subroutine.
  *
  */

 #include "windows.h"

 long FAR PASCAL SampleWindowProc (HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Sendmsg";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = SampleWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND   hWnd;                /* Handle to the parent window     */
     MSG    msg;                 /* Message received from the queue */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Sendmsg",
                         (LPSTR)"Sending Messages",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Sending the window a WM_DESTROY message directly to the
      * window procedure immediately
      */
     MessageBox (hWnd, (LPSTR)"Sending the window a destroy message",
                 (LPSTR)"SENDING", MB_OK);
     SendMessage (hWnd, WM_DESTROY, 0,0L);

     return 0;
 }

 /* The window procedure for this program */
 long FAR PASCAL SampleWindowProc (hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message)
       {  case WM_DESTROY:
            MessageBox (hWnd, (LPSTR)"Destroy Message Received",
                        (LPSTR)"RECEIVED", MB_OK);
            PostQuitMessage (0);
            break;

          default:
            return (DefWindowProc (hWnd, message, wParam, lParam));
            break;
       }
     return 0L;
 }


 SETACTWN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\SETACTWN.C

 /*
  *  SetActiveWindow
  *  setactwn.c,
  *
  *  This program demonstrates the use of the function SetActiveWindow.
  *  It makes a tiled window or popup style window the active window.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setactwn";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG          msg;                 /* Window messages                */
     HWND         hWnd;                /* Handle to the parent window    */
     HDC          hDC;                 /* Display context of client area */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setactwn",
                         (LPSTR)"Active Window",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Message Box will make the parent window inactive */
     MessageBox (hWnd, (LPSTR)"The window is not active\n(Look at the caption
                 (LPSTR)"Before", MB_OK);

     /* make the window becomes the active window */
     SetActiveWindow (hWnd);
     hDC = GetDC (hWnd);
     TextOut (hDC, 10, 10, (LPSTR)" Now this window is active.", 26);
     ReleaseDC (hWnd, hDC);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
       {
         TranslateMessage ((LPMSG)&msg);
         DispatchMessage  ((LPMSG)&msg);
       }

     return (int)msg.wParam;
 }


 SETBKCOL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\SETBKCOL.C

 /*
  *  SetBKColor
  *  setbkcol.c,
  *
  *  This program demonstrates the use of the function SetBkColor.  The
  *  change in the backround color is demonstrated using the TextOut function.
  *  The color of the text is also changed so that it can be seen against
  *  against the new backround color.
  *
  */

 #include "windows.h"
  ERR 0x80000000 /* Error value returned by SetBkColor
       * if an error occurs */

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;            /* Handle to the parent window  */
     HDC   hDC;          /* Handle to the display context of client area */
     DWORD rgbcolor;        /* Return value from SetTextColor routine */
     DWORD black = RGB(0x00,0x00,0x00); /* Color of text backround      */
     DWORD white = RGB(0xff,0xff,0xff); /* Color of the output text     */
     long  lpReturn;           /* Return value for SetBkColor  */


     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
       (LPSTR)"SetBkColor",
                         WS_TILEDWINDOW,
                         20,20,400,200,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     hDC = GetDC (hWnd);

        /* The following text will be black so it can be seen
         * on the white backround         */
     TextOut(hDC,
       0,
       0,
       (LPSTR) "The backround color is white before invoking SetBkColor.",
       strlen ("The backround color is white before invoking SetBkColor.")
       );

 /**************************************************************************/
 /* SetBkColor sets the backround color of future text output to black.
  * The parameters needed are a handle to a display context (hDC) and
  * and an RGB color value - black in this case        */

     lpReturn  = SetBkColor(hDC,black); /* lpReturn contains 80000000H if
           * an error occurs */

 /**************************************************************************/

     SetTextColor(hDC,white); /* Set the text color to white to
             * so the text can be seen on the
             * black backround */

     TextOut(hDC,
       0,
       15,
       (LPSTR) "The backround color is black after invoking SetBkcolor.",
       strlen ("The backround color is black after invoking SetBkcolor.")
      );
     ReleaseDC (hWnd, hDC);

     if (lpReturn = ERR)
       MessageBox (hWnd, (LPSTR)"The backround color is changed. No errors",
       (LPSTR)"Done", MB_OK);

     return 0;
 }


 SETBKMD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\SETBKMD.C

 /*
  *  SetBkMode
  *  setbkmd.c
  *
  *  This program demonstrates the use of the function SetBkMode.
  *  It sets the background mode used with text, hatched brushes, and
  *  line styles. This program only illustrates with text in the client
  *  area.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setbkmd";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( LTGRAY_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;                        /* Handle to the parent window    */
     HDC   hDC;                         /* Display context of client area */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setbkmd",
                         (LPSTR)"Setting Background Mode",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Get a DC before writing to the client area */
     hDC = GetDC (hWnd);

     /* The default background mode is Opaque */
     TextOut(hDC, 20, 10, (LPSTR) "This is Opaque Background Mode", 30);

     /* Change the background mode to Transparent */
     SetBkMode (hDC, TRANSPARENT);
     TextOut(hDC, 20, 30, (LPSTR) "This is Transparent Background mode", 35);

     ReleaseDC (hWnd, hDC);

     MessageBox (hWnd, (LPSTR)"The background mode has changed", (LPSTR)"Done"

     return 0;
 }


 SETBLT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SETBLT.C

 /*
  *
  *  SetStretchBltMode
  *  setblt
  *
  *  SetStretchBltMode sets the stretching mode for the StretchBlt function.
  *  The stretching mode defines which scan lines and/or columns
  *  StretchBlt eliminates when contracting a bitmap.
  *
  *  This program demonstrates the use of the function SetStretchBltMode.
  *  The stretch mode is set in one statement.  The SetStretchBltMode function
  *  is passed two parameters: a handle to a display context,(ie. hDC) and a
  *  new stretching mode (ie. WHITEONBLACK, BLACKONWHITE, or COLORONCOLOR).
  *  SetStretchBltMode returns the previous stretching mode.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;             /* Handle to the parent window    */
     short nOldStretchMode;  /* Return value for the SetStretchBltMode Routine
     HDC   hDC;              /* display context of client area */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
                         (LPSTR)"SetStretchBltMode",
                         WS_TILEDWINDOW,
                         20,20,400,200,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow(
     hWnd );
     /************************************************************************
     hDC = GetDC (hWnd);          /* Get a handle to the Display Context */

     /* Set the stretching mode for the StretchBlt function and return the
      * previous stretching mode in a (short) variable. */
     nOldStretchMode = SetStretchBltMode ( hDC, WHITEONBLACK);

     ReleaseDC (hWnd, hDC);        /* Release handle to Display Context */
     /************************************************************************

     /* return codes for SetStretchBltMode routine */
     if (nOldStretchMode == WHITEONBLACK)
       {  MessageBox (hWnd, (LPSTR)"The stretching mode is set. The previous m
          (LPSTR)"Done", MB_OK);
       }
     else if (nOldStretchMode == BLACKONWHITE)
      {  MessageBox (hWnd, (LPSTR)"The stretching mode is changed. The previou
         (LPSTR)"Done", MB_OK);
      }
     else if (nOldStretchMode == COLORONCOLOR)
     {   MessageBox (hWnd, (LPSTR)"The stretching mode is changed. The previou
         (LPSTR)"Done", MB_OK);
     }
     return 0;
 }


 SETCAPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\SETCAPOS.C

 /*
  *  SetCaretPos
  *  setcapos.c
  *
  *  This program demonstrates the use of the function SetCaretPos.
  *  It moves the caret to the position specified by the parameters. The
  *  movement applies to the caret whether it is visible or hidden.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcapos";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;                /* Handle to the parent window    */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setcapos",
                         (LPSTR)"Setting Caret Position",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Create a caret before showing */
     CreateCaret (hWnd, NULL, 8, 12);
     SetCaretPos (50,50);
     ShowCaret (hWnd);
     /* Message Box will make the parent window inactive */
     MessageBox (hWnd, (LPSTR)"This is the current caret position",
                 (LPSTR)"Before", MB_OK);

     /* move the caret to a new location */
     SetCaretPos (50,125);
     MessageBox (hWnd, (LPSTR)"Now the caret is moved to a new position",
                 (LPSTR)"After", MB_OK);

     return 0;
 }


 SETCAPT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\SETCAPT.C

 /*
  *  SetCapture() & ReleaseCapture()
  *  setcapt.c
  *
  *  This program demonstrates the use of the functions SetCapture()
  *  and ReleaseCapture(). It causes all subsequent mouse input to be
  *  sent to the specified window, regardless of the position of the
  *  mouse cursor. Capture can be released by pressing the right
  *  mouse button.
  *
  */

 #include "windows.h"
 #include "stdio.h"
 #include "string.h"

 long FAR PASCAL SampleWindowProc (HWND, unsigned, WORD, LONG);

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcapt";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = SampleWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND   hWnd;                /* Handle to the parent window    */
     MSG    msg;                 /* Window messages                */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setcapt",
                         (LPSTR)"Setting Mouse Capture",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* All mouse input will be sent to this window */
     MessageBox (hWnd, (LPSTR)"Press OK to capture the mouse", (LPSTR)"Start",
     SetCapture (hWnd);

     /* The window message loop */
     while (GetMessage ((LPMSG)&msg, NULL, 0, 0))
       {
          TranslateMessage ((LPMSG)&msg);
          DispatchMessage  ((LPMSG)&msg);
       }

     return (int)msg.wParam;
 }


 /* The window procedure */
 long FAR PASCAL SampleWindowProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
     POINT ptMousePos;      /* The location of the current mouse position */
     HDC   hDC;             /* Handle to the display context              */
     char  szBuffer[40];    /* String buffer used for output              */
     short nBytes;          /* Number of character in the string buffer   */

     switch (message)
       {
         case WM_PAINT:
           hDC = GetDC (hWnd);
           TextOut (hDC, 10, 10, (LPSTR)"Even when the mouse is out of this wi
           TextOut (hDC, 10, 20, (LPSTR)"the mouse input is still sent to this
           TextOut (hDC, 10, 30, (LPSTR)"Press the right mouse button to relea
           ValidateRect (hWnd, (LPRECT)NULL);
           ReleaseDC (hWnd, hDC);
           break;

         /* All the mouse messages will come through this window procedure
          * after the mouse is captured, even if the mouse is outside of
          * this window.
          */
         case WM_MOUSEMOVE:
           hDC = GetDC (hWnd);
           ptMousePos = MAKEPOINT (lParam);
           nBytes = sprintf (szBuffer, "The Mouse is now at: X = %d, Y = %d
                             ptMousePos.x, ptMousePos.y);
           TextOut (hDC, 50, 50, (LPSTR)szBuffer, nBytes);
           ReleaseDC (hWnd, hDC);
           break;

         /* The mouse must be released before you can exit this program */
         case WM_RBUTTONDOWN:
           ReleaseCapture();
           MessageBox (hWnd, (LPSTR)"Mouse is released",
                       (LPSTR)"ReleaseCapture()", MB_OK);
           break;

         default:
           return (DefWindowProc (hWnd, message, wParam, lParam));
           break;
       }
     return 0L;
 }


 SETCARBT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\SETCARBT.C

 /*
  *  SetCaretBlinkTime
  *  setcarbt.c
  *
  *  This program demonstrates the use of the function SetCaretBlinkTime.
  *  It establishes the caret flash rate for the client area.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcarbt";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;                /* Handle to the parent window    */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setcarbt",
                         (LPSTR)"Setting Caret Blink Time",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* create a caret before showing it */
     CreateCaret (hWnd, NULL, 8, 12);
     SetCaretPos (50,50);
     ShowCaret (hWnd);
     /* Message Box will make the parent window inactive */
     MessageBox (hWnd, (LPSTR)"This is a slower caret blink time",
                 (LPSTR)"Before", MB_OK);

     /* make the caret blink faster by decreasing the delay time */
     SetCaretBlinkTime (GetCaretBlinkTime()/2);
     MessageBox (hWnd, (LPSTR)"Now the caret is twice as fast",
                 (LPSTR)"After", MB_OK);

     return 0;
 }


 SETCL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\SETCL.C

 /*

 Function(s) demonstrated in this program: SetClassLong

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:   This function replaces the long value in the window class
    structure corresponding to the window handle parameter, with the
    respective new value.

 Additional Comments:  This program requests 4 extra bytes when it registers
    its class structure.  These 4 extra bytes are used to store a long
    value corresponding to the number of instances of windows in this class.
    This value is updated using GetClassLong and SetClassLong and an upper
    bound of 3 windows of this class is enforced.


 */

 #define NOMINMAX
 #include <stdlib.h>
 #include <windows.h>
 #include "SetCl.h"
 #include "string.h"
 #include "stdio.h"

        char         szAppName             [] = "SetCl"             ;
        HANDLE       hInstMain                                      ;
        HWND         hWndMain                                       ;
        char         szOutputBuffer1       [70]                     ;
        char         szOutputBuffer2       [500]                    ;
        HBITMAP      hBitmapHelp                                    ;


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use  of  the  SetClassLong  Windows function.",

 "Help Message",
 "     This program uses GetClassLong and\n\
 SetClassLong to keep track of the number of windows\n\
 of this class.  In order to do this four bytes must\n\
 be reserved in the class structure using the\n\
 cbClsExtra field in the class the first time it is\n\
 initialized.  To test this program try to run more\n\
 than three instances.  When trying to run a fourth\n\
 instance, the program will state that the limit has\n\
 been reached and automatically terminate.",

 "Warning",
 "     Only Three windows of this class are allowed\n\
 at any one time.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;
     LONG    WindowCount;


     if (!hPrevInstance)
   {
   wndclass.style           = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
   wndclass.lpfnWndProc    = WndProc;
   wndclass.cbClsExtra     = 4;
   wndclass.cbWndExtra     = 0;
   wndclass.hInstance      = hInstance;
   wndclass.hIcon           = NULL;
    wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = szAppName;
   wndclass.lpszClassName  = szAppName;

     if (!RegisterClass (&wndclass) )
         return FALSE;
     }

     hWnd = CreateWindow (szAppName, "SetClassLong Main",
            WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
            NULL, NULL, hInstance, NULL);

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

     WindowCount = GetClassLong (hWnd, 0);
     sprintf (szOutputBuffer1,
              "     Number of windows with this class currently running = %i."
              WindowCount + 1);
     MessageBox (hWnd, szOutputBuffer1, "SetClassLong", MB_OK);

     if (WindowCount < MAXWINDOWS) {
        WindowCount += 1;
        SetClassLong (hWnd, 0, WindowCount);
     }
     else {
        ProcessMessage (hWnd, 4);
        SendMessage (hWnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
     }

     while (GetMessage (&msg, NULL, 0, 0))
         {
         TranslateMessage (&msg);
         DispatchMessage (&msg);
         }
     return msg.wParam;
 }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
    HWND      hWnd;
    unsigned  iMessage;
    WORD      wParam;
    LONG      lParam;
    {
    HMENU     hMenu;

    switch (iMessage)
        {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             break;

        case WM_SIZE:
             break;

        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
             break;


        case WM_COMMAND:
             switch (wParam) {
                case IDM_HELP:
                     ProcessMessage (hWnd, 2);
                     break;
            }
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }



 SETCLSWD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\SETCLSWD.C

 /*
  *  SetClassWord
  *  setclswd.c
  *
  *  This program demonstrates the use of the function SetClassWord.
  *  It replaces the word at the specified index in the WNDCLASS structure
  *  of the window. It is used to change the attributes of the window class
  *  after the window class has been registered.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setclswd";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND    hWnd;              /* Handle to the parent window    */
     HCURSOR hCursor;           /* Handle to the brushes          */
     MSG     msg;               /* Window messages                */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setclswd",
                         (LPSTR)"Changing Window Class Information",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* SetClassWord is used here to change the cursor in the window class
      * structure. It can be used also to change the icon, window style, and
      * other attributes of the window class.
      */
     MessageBox (hWnd, (LPSTR)"This is the old cursor", (LPSTR)"Before", MB_OK
     hCursor = LoadCursor (NULL, IDC_CROSS);
     SetClassWord (hWnd, GCW_HCURSOR, hCursor);
     MessageBox (hWnd, (LPSTR)"Press OK to see the new cursor", (LPSTR)"After"

     /* the message loop */
     while (GetMessage ((LPMSG) &msg, NULL, 0, 0))
       {
          TranslateMessage ((LPMSG) &msg);
          DispatchMessage ((LPMSG) &msg);
       }

     return (int) msg.wParam;
 }


 SETCOMMS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\SETCOMMS.C

 /*
  *  SetCommState
  *  setcomms.c
  *
  *  This program demonstrates the use of the function SetCommState.
  *  It sets a communication device to the state specified by the
  *  device control block (DCB) . This function call is necessary
  *  to set the communication to the desired configurations before
  *  any communication should take place.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcomms";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;            /* Handle to the parent window               */
     short nCid;            /* Short integer identifying the opened
                             * communication device                      */
     short nFlag;           /* Result of the SetCommState function call  */
     DCB   dcb;             /* The device control block                  */

     WinInit( hInstance );

     hWnd = CreateWindow((LPSTR)"Setcomms",
                         (LPSTR)"Setting Communication Device",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* attempt to open the com1 port */
     nCid = OpenComm ((LPSTR)"COM1", 20, 20);
     if (nCid < 0)
       {
         MessageBox (hWnd, (LPSTR)"Com port not opened!!",(LPSTR)NULL,MB_OK);
         return 0;
       }


     /* Get the current setting of the communication device and then
      * made modifications to each field of the device control block.
      */
     if (GetCommState (nCid, (DCB FAR *) &dcb) >= 0)
       { dcb.BaudRate = 9600;
         dcb.ByteSize = 8;
         dcb.StopBits = ONESTOPBIT;
         dcb.Parity   = NOPARITY;
         dcb.fRtsflow = FALSE;
         dcb.fDtrflow = FALSE;
         dcb.fOutX    = FALSE;
         dcb.fInX     = FALSE;
         dcb.fNull    = FALSE;
         dcb.XonLim   = 1;
         dcb.XoffLim  = 20;
       }

     nFlag = SetCommState ((DCB FAR *) &dcb);

     /* Check the return value of SetCommState to see if the function
      * was successful
      */
     if (nFlag == 0)
       MessageBox (hWnd, (LPSTR)"Communication device set successfully",
                   (LPSTR)"OK", MB_OK);

     if (nFlag < 0)
       MessageBox (hWnd, (LPSTR)"Communication device not set",
                   (LPSTR)NULL, MB_OK);


     /* must close the communication device before leaving the program */
     CloseComm (nCid);

     return 0;
 }


 SETCSRPS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\SETCSRPS.C

 /*
  *  SetCursorPos
  *  setcsrps.c
  *
  *  This program demonstrates the use of the function SetCursorPos.
  *  It moves the system cursor to the coordinates specified by the
  *  X and Y parameters.
  *
  */

 #include "windows.h"

 /*************************** GLOBAL VARIABLES *************************/
 static  HWND  hWnd;
 static  RECT  rect;
 /******************** WINMAIN -- Main Windows Procedure ***************/
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance;
 HANDLE    hPrevInstance;
 LPSTR    lpszCmdLine;
 int    cmdShow;
 {
     MSG  msg;
     int  xCoord;
     int  yCoord;

   if (!hPrevInstance) {
     /* ensure that windows know where to find parts of this
      * task on disk by Registering a window class.  Registering
      * a class binds an executable name to an internal name,
      * known to Windows. */
     WNDCLASS  rClass;

     rClass.lpszClassName  = (LPSTR)"SetCursorPos";
     rClass.hInstance  = hInstance;
     rClass.lpfnWndProc  = DefWindowProc;
     rClass.hCursor    = LoadCursor (NULL, IDC_ARROW);
     rClass.hIcon    = LoadIcon (hInstance, (LPSTR)"SetCursorPos");
     rClass.lpszMenuName  = (LPSTR) NULL;
     rClass.hbrBackground  = GetStockObject (WHITE_BRUSH);
     rClass.style    = CS_HREDRAW | CS_VREDRAW;
     rClass.cbClsExtra  = 0;
     rClass.cbWndExtra  = 0;

     RegisterClass ((LPWNDCLASS) &rClass);
     } /* end if this is the 1st task/instance of this program */

   hWnd = CreateWindow (  (LPSTR) "SetCursorPos", /* Window class name */
         (LPSTR) "SetCursorPos", /* Window title */
         WS_OVERLAPPEDWINDOW,
           /* stlye -- WIN 2.x or later */
         CW_USEDEFAULT,  /* x -  WIN 2.x or later */
         CW_USEDEFAULT,  /* y -  WIN 2.x or later */
         CW_USEDEFAULT,  /* cx - WIN 2.x or later */
         CW_USEDEFAULT,  /* cy - WIN 2.x or later */
         (HWND)NULL,  /* No parent */
         (HMENU)NULL,  /* Use the class menu */
         (HANDLE)hInstance, /* .EXE file for Class */
         (LPSTR)NULL  /* No Params */
            );
   ShowWindow (hWnd, cmdShow);     /* Allocate room for window     */
   UpdateWindow (hWnd);            /* Paint the client area        */

   MessageBox (hWnd, (LPSTR) "Moving the Cursor to the Top-Left Corner", (LPST
   GetClientRect (hWnd, (LPRECT)&rect);
   xCoord = rect.left;
   yCoord = rect.top;

   /* SetCursorPos is used here to move the cursor to the top-left
    * corner of the screen.  */
   SetCursorPos (xCoord, yCoord);

   MessageBox (hWnd, (LPSTR) "Demonstration Finished", (LPSTR) " ",MB_OK);
   exit (0);
 } /* WINMAIN */


 SETCURSO.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\SETCURSO.C

 /*
  *
  *  SetCursor
  *  setcurso.c
  *
  *  This program demonstrates the use of the function SetCursor.
  *  It sets the cursor shape to the cursor specified by hCursor. HCursor
  *  is a handle to a cursor resource, which must have been loaded
  *  previously using the LoadCursor function. The cursor is set only if the
  *  new shape is different from the existing shape. If hCursor is NULL, the
  *  cursor is removed from the screen. To change the cursor while it is in
  *  a window, the class cursor for the given window's class must be set to
  *  NULL. If the class cursor is not null, Windows restores the old shape
  *  each time the mouse moves.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = (HCURSOR)NULL;
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setcurso";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND    hWnd;              /* Handle to the parent window    */
     HCURSOR hCursor;           /* Handle to the cursor           */
     MSG     msg;               /* Window messages                */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setcurso",
                         (LPSTR)"Changing Cursor",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Setting the new cursor */
     MessageBox (hWnd, (LPSTR)"This is the old cursor", (LPSTR)"Before", MB_OK
     hCursor = LoadCursor (NULL, IDC_CROSS);
     MessageBox (hWnd, (LPSTR)"Press OK to see the new cursor",
                 (LPSTR)"After", MB_OK);
     SetCursor (hCursor);

     /* Window message loop */
     while (GetMessage ((LPMSG) &msg, NULL, 0, 0))
       {
          TranslateMessage ((LPMSG) &msg);
          DispatchMessage ((LPMSG) &msg);
       }

     return (int) msg.wParam;
 }


 SETDBLCK.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\SETDBLCK.C

 /*
  *  SetDoubleClickTime
  *  setdblck.c
  *
  *  This program demonstrates the use of the function SetDoubleClickTime.
  *  This function changes the range of time Windows will wait to
  *  acknowledge a double-click from the mouse.
  *
  */

 #include "windows.h"

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE          hInstance;
 HANDLE          hPrevInstance;
 LPSTR           lpszCmdLine;
 int             cmdShow;
 {
                 static WORD     wTime;
                 static WORD     NewDblCkTime = 1000;
                 static char     szbuff[80];

         wTime = GetDoubleClickTime ();
         sprintf ( szbuff, "%s%ld", "Current Double click time in milliseconds
         MessageBox (NULL, (LPSTR)szbuff, (LPSTR)"SetDoubleClickTime", MB_OK);

         SetDoubleClickTime (NewDblCkTime);

         wTime = GetDoubleClickTime ();
         sprintf ( szbuff, "%s%ld", "New Double click time in milliseconds is
         MessageBox (NULL, (LPSTR)szbuff, (LPSTR)"Program Finished", MB_OK);

         exit (0);
 }


 SETENV.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ENVIRON\SETENV.C

 /*
  *  SetEnvironment
  *  Setenv.c
  *
  *  This program demonstrates the use of the function SetEnvironment.
  *  This function copies the contents of the buffer specified by the second
  *  parameter into the environment associated with the device attached to
  *  the system port specified by the first parameter.
  *
  */

 #include <windows.h>
 #include "setenv.h"

 LPSTR far PASCAL lstrcpy( LPSTR, LPSTR );

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   short nCopied;
   DEVMODE devmode;

   lstrcpy ( (LPSTR) devmode.DeviceName, (LPSTR) "HP LaserJet Series II" );
   devmode.orient = PORTRAIT;
   devmode.cartridge = DEFAULT_CTG + CARTRIDGE;
   devmode.paper = LETTER;

   MessageBox ( NULL, (LPSTR) "Setting environment", (LPSTR) "SetEnvironment",
      MB_OK );

   nCopied = SetEnvironment ( (LPSTR) "LPT1:", (LPSTR) &devmode,
      sizeof (DEVMODE) );

   if ( nCopied == 0 )
      MessageBox (NULL, (LPSTR)"Environment not set!", (LPSTR)"SetEnvironment"
         MB_OK|MB_ICONEXCLAMATION);
   else
      MessageBox (NULL, (LPSTR)"Environment set", (LPSTR)"SetEnvironment",
         MB_OK);

   return 0;
 }


 SETMSGQU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\SETMSGQU.C

 /*
 Windows Version 2.03 function demonstration application

 Function(s) demonstrated in this program: SetMessageQueue

 Compiler version: 5.01

 Description:

 This program calls SetMessageQueue to destroy the old message queue
 and create a new message queue which can hold up to ten messages. The
 default message queue can hold only eight messages.  The results of
 the call to SetMessageQueue are displayed on the screen.  If the call
 works then a new message queue is created and the old message queue
 is destroyed, along with any messages it might contain.  If the call
 fails then the old message queue is still destroyed but a new message
 queue has not been created.  In the latter case the application must
 continue calling SetMessageQueue with a smaller queue size until the
 function returns a nonzero value.


 ****************************************************************************/

 #include <windows.h>
 #include <string.h>

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "SetMessageQueue" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "SetMessageQueue",          /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  PAINTSTRUCT     ps;
  HDC             hDC;
  TEXTMETRIC      tm;
  static short    xChar,
                  yChar;
  short           iRow; /* An index to keep track of the current row *
                         * for text output
                        */

  switch(iMessage)
  {
   case WM_CREATE:
   {
    hDC = GetDC (hWnd);
    GetTextMetrics (hDC, &tm);
    xChar = tm.tmAveCharWidth;
    yChar = tm.tmHeight + tm.tmExternalLeading;
    ReleaseDC (hWnd, hDC);
    break;
   }
   case WM_PAINT:
   {
    hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);

    iRow = 1;

 LOOP:
    if (SetMessageQueue(10) == 0)
       {
        TextOut (hDC,
                xChar,
                yChar * iRow,
                (LPSTR)"SetMessageQueue has failed.  The application has no me
                strlen("SetMessageQueue has failed.  The application has no me
               );

       iRow++;
       goto LOOP;
       }
    else
       {
        TextOut (hDC,
                xChar,
                yChar * iRow,
                (LPSTR)"SetMessageQueue works.",
                strlen("SetMessageQueue works.")
               );

        TextOut (hDC,
                xChar,
                yChar * ++iRow,
                (LPSTR)"The message queue for this application will now hold t
                strlen("The message queue for this application will now hold t
               );

        TextOut (hDC,
                xChar,
                yChar * ++iRow,
                (LPSTR)"Before the SetMessageQueue call it only held eight mes
                strlen("Before the SetMessageQueue call it only held eight mes
               );

       }
    EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 SETPAR.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\SETPAR.C

 /*

 Function(s) demonstrated in this program: SetParent

 Description:  This function changes the parent of the respective child
     window.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "SetPar.h"


 HWND     hWndParent1, hWndParent2, hWndChild1, hWndChild2;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use  of  the  SetParent Windows function.",

 "Help Message",
 "     This program uses the SetParent Windows\n\
 function to change the parent of the child windows.\n\
 Use the menu to choose the parent."

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "SetPar" ;
      static char szChildClass [] = "SetParChild" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;
      short       xScreen, yScreen ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;

           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = ChildWndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = NULL ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_CROSS) ;
           wndclass.hbrBackground = GetStockObject (LTGRAY_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szChildClass ;

           if (!RegisterClass (&wndclass))
                return FALSE ;

           }

      xScreen = GetSystemMetrics (SM_CXSCREEN) ;
      yScreen = GetSystemMetrics (SM_CYSCREEN) ;

      hWndParent1 = CreateWindow (szAppName,     /* window class name       */
                     "Parent 1",                 /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     xScreen / 9,                /* initial x position      */
                     yScreen / 7,                /* initial y position      */
                     xScreen * 3 / 9,            /* initial x size          */
                     yScreen * 6 / 9,            /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent1, nCmdShow) ;
      UpdateWindow (hWndParent1) ;

      hWndParent2 = CreateWindow (szAppName,     /* window class name       */
                     "Parent 2",                 /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     xScreen * 5 / 9,            /* initial x position      */
                     yScreen / 7,                /* initial y position      */
                     xScreen * 3 / 9,            /* initial x size          */
                     yScreen * 6 / 9,            /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndParent2, nCmdShow) ;
      UpdateWindow (hWndParent2) ;

      hInstMain = hInstance;

      hWndChild1 = CreateWindow (szChildClass, "Child 1", WS_CHILD |
                     WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MAXIMIZEBOX
                     WS_CLIPSIBLINGS,
                     0, 0, xScreen / 8, yScreen / 6,
                     hWndParent1, 1, hInstance, NULL) ;

      ShowWindow (hWndChild1, SW_SHOWNORMAL) ;
      UpdateWindow (hWndChild1) ;

      hWndChild2 = CreateWindow (szChildClass, "Child 2", WS_CHILD |
                     WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MAXIMIZEBOX
                     WS_CLIPSIBLINGS,
                     0, yScreen / 5, xScreen / 8, yScreen / 6,
                     hWndParent1, 1, hInstance, NULL) ;

      ShowWindow (hWndChild2, SW_SHOWNORMAL) ;
      UpdateWindow (hWndChild2) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  PAINTSTRUCT ps;
  static int  xClient, yClient;
  static int  xDevisor, yDevisor, randNum, Index;
  char        szOutputBuffer [40];

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_SETPARENT1:
                SetParent (hWndChild1, hWndParent1);
                SetParent (hWndChild2, hWndParent1);
                break;

           case IDM_SETPARENT2:
                SetParent (hWndChild1, hWndParent2);
                SetParent (hWndChild2, hWndParent2);
                break;

           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }

 /****************************************************************************

 long FAR PASCAL ChildWndProc (hWnd, iMessage, wParam, lParam)
      HWND     hWnd ;
      unsigned iMessage ;
      WORD     wParam ;
      LONG     lParam ;
      {
      return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
      }



 SETPIXEL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SETPIXEL.C

 /*
  *  SetPixel
  *  setpixel.c
  *
  *  This program demonstrates the use of the function SetPixel.
  *  It sets the pixel at the point specified by the X and Y coordinates
  *  to the closest approxmiation to the color specified by the rgbcolor.
  *  The point must be in the clipping region. If the point is not in the
  *  clipping region, the function is ignored.
  *
  */

 #include "windows.h"

 /* Registering the parent window class */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setpixel";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS) &wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;                   /* Handles to the windows        */
     HDC   hDC;                    /* Display context of the window */
     short nPos;                   /* X-coordinate of the pixel     */
     LONG  nResult;                /* return value of SetPixel      */

     WinInit (hInstance);

     /* creating the window */
     hWnd = CreateWindow((LPSTR)"Setpixel",
                         (LPSTR)"Setting Pixel",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Getting the display context and draw a line by setting a series of
      * pixels in the client area. The rgbcolor is set by using RGB macro.
      */
     hDC = GetDC (hWnd);

     for (nPos = 50; nPos < 550; nPos++)
       {
         nResult = SetPixel (hDC, nPos, 50, RGB (0,0,0));
         if (nResult == -1)
           MessageBox (hWnd, (LPSTR)"SetPixel Function Failed",
                       (LPSTR)"ERROR!", MB_OK);
       }

     ReleaseDC (hWnd, hDC);

     MessageBox (hWnd, (LPSTR)"Using SetPixel to draw a line",
                 (LPSTR)"Done", MB_OK);

     return 0;
 }


 SETPRI.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\SETPRI.C

 /*
  *  SetPriority
  *  setpri.c
  *
  *  This program modifies its priority using the SetPriority function.  It
  *  has two menu items.  One to set the priority high and the other to set
  *  it low.
  *
  */

  "windows.h"      /* required for all Windows applications */
  "setpri.h"       /* specific to this program              */

 HANDLE hInst;             /* current instance                      */

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;         /* current instance             */
 HANDLE hPrevInstance;     /* previous instance            */
 LPSTR lpCmdLine;          /* command line                 */
 int nCmdShow;             /* show-window type (open/icon) */
 {
     HWND hWnd;            /* window handle       */
     MSG msg;              /* message             */
     HANDLE hMenu;         /* Handle to the menu  */

     if (!hPrevInstance)              /* Has application been initialized? */
         if (!SetPriInit(hInstance))
             return (NULL);           /* Exits if unable to initialize     */

     hInst = hInstance;               /* Saves the current instance        */

     hMenu = LoadMenu( hInst, (LPSTR)"SetPriMenu" );
                                      /*  Load the menu    */

     hWnd = CreateWindow("SetPri",   /* window class      */
         "SetPri Sample Application",  /* window name       */
         WS_OVERLAPPEDWINDOW,         /* window style      */
         CW_USEDEFAULT,               /* x position        */
         CW_USEDEFAULT,               /* y position        */
         CW_USEDEFAULT,               /* width             */
         CW_USEDEFAULT,               /* height            */
         NULL,                        /* parent handle     */
         hMenu,                       /* menu or child ID  */
         hInstance,                   /* instance          */
         NULL);                       /* additional info   */

     if (!hWnd)                       /* Was the window created? */
         return (NULL);

     ShowWindow(hWnd, nCmdShow);      /* Shows the window        */
     UpdateWindow(hWnd);              /* Sends WM_PAINT message  */

     while (GetMessage(&msg,     /* message structure                      */
             NULL,               /* handle of window receiving the message */
             NULL,               /* lowest message to examine              */
             NULL))              /* highest message to examine             */
         {
         TranslateMessage(&msg);  /* Translates virtual key codes           */
         DispatchMessage(&msg);   /* Dispatches message to window           */
     }
     return (msg.wParam);         /* Returns the value from PostSetPriMessage
 }

 BOOL SetPriInit(hInstance)
 HANDLE hInstance;                /* current instance           */
 {
     HANDLE hMemory;              /* handle to allocated memory */
     PWNDCLASS pWndClass;         /* structure pointer          */
     BOOL bSuccess;               /* RegisterClass() result     */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = SetPriWndProc;
     pWndClass->hInstance = hInstance;
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->lpszMenuName = (LPSTR) "SetPriMenu";
     pWndClass->lpszClassName = (LPSTR) "SetPri";

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);     /* Unlocks the memory    */
     LocalFree(hMemory);       /* Returns it to Windows */

     return (bSuccess);        /* Returns result of registering the window */
 }

 long FAR PASCAL SetPriWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                    /* window handle                   */
 unsigned message;             /* type of message                 */
 WORD wParam;                  /* additional information          */
 LONG lParam;                  /* additional information          */
 {
     FARPROC lpProcAbout;      /* pointer to the "About" function */
     HMENU hMenu;              /* handle to the System menu       */

     switch (message) {
         case WM_SYSCOMMAND:   /* message: command from system menu */
             if (wParam == ID_ABOUT) {
                 lpProcAbout = MakeProcInstance(About, hInst);

                 DialogBox(hInst,         /* current instance         */
                     "AboutBox",          /* resource to use          */
                     hWnd,                /* parent handle            */
                     lpProcAbout);        /* About() instance address */

                 FreeProcInstance(lpProcAbout);
                 break;
             }

             else                         /* Lets Windows process it       */
                 return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CREATE:                  /* message: window being created */

             /* Get the handle of the System menu */

             hMenu = GetSystemMenu(hWnd, FALSE);

             /* Add a separator to the menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 NULL,                            /* new menu item       */
                 NULL,                            /* menu identifier     */
                 MF_APPEND | MF_SEPARATOR);       /* type of change      */

             /* Add new menu item to the System menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 "A&bout SetPri...",             /* new menu item       */
                 ID_ABOUT,                        /* menu identifier     */
                 MF_APPEND | MF_STRING);          /* type of change      */
             break;

         case WM_COMMAND:
             if ( wParam == IDM_HIGH )
               SetPriority( GetCurrentTask(),  /*  Priority of current task  *
                            -15 );  /*  -15 is the highest priority  */
             if ( wParam == IDM_LOW )
               SetPriority( GetCurrentTask(),  /*  Again, the current task  */
                            15 );  /*  15 is the lowest priority  */

 /*  The default value for the priority is zero  */

             break;

         case WM_DESTROY:             /* message: window being destroyed */
             PostQuitMessage(0);
             break;

         default:                     /* Passes it on if unproccessed    */
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:              /* message: initialize dialog box */
             return (TRUE);

         case WM_COMMAND:                 /* message: received a command */
             if (wParam == IDOK) {        /* "OK" box selected?          */
                 EndDialog(hDlg, NULL);   /* Exits the dialog box        */
                 return (TRUE);
             }
             break;
     }
     return (FALSE);                      /* Didn't process a message    */
 }


 SETPROP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\SETPROP.C

 /*
  *  SetProp
  *  setprop.c
  *
  *  This program demonstrates the use of the function SetProp.
  *  It copies the character string and a data handle to the property
  *  list of the window. The string serves as a label for the data handle.
  *  The data handle can be retrieved from the property list at any time
  *  by using the GetProp function and specifying the string.
  *
  */

 #include "windows.h"
 #include "stdio.h"

 /* This is the structure that is used to put into the property list.
  * It is just a sample structure.
  */
 struct Data
   {  short nRow, nSeat;
      char  szName[20];
   } strSeatings = { 2, 4, "John Smith" };



 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setprop";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;          /* Handle to the parent window    */
     BOOL         bSet;          /* Boolean flag                   */
     struct Data *hData;         /* Handle to the data in the
                                  * property list
                                  */
     char         szbuffer[50];  /* String buffer for output       */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setprop",
                         (LPSTR)"Setting the Property List",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );


     /* Putting the structure into the property list of the window
      * If it is successful, retrieve it to check if the correct structure
      * is put into the property list
      */
     bSet = SetProp (hWnd, (LPSTR)"Smith", (HANDLE) &strSeatings);
     if (bSet)
       {
         MessageBox (hWnd, (LPSTR)"Property Set", (LPSTR)"OK", MB_OK);
         hData = GetProp (hWnd, (LPSTR)"Smith");
         sprintf (szbuffer, "%s at row %d, seat# %d",
                  hData->szName, hData->nRow, hData->nSeat);
         MessageBox (hWnd, (LPSTR)szbuffer, (LPSTR)"Retrieved", MB_OK);
       }
     else
       MessageBox (hWnd, (LPSTR)"Property Not Set", (LPSTR)"FAIL", MB_OK);

     return 0;
 }


 SETRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\SETRECT.C

 /*
  *  SetRect
  *  setrect.c
  *
  *  This program demonstrates the use of the function SetRect.
  *  The SetRect functions creates a new RECT structure with the values
  *  given by the last four parameters.
  *
  */

 #include "windows.h"

 /*************************** GLOBAL VARIABLES *************************/
 static  HWND    hWnd;

 /************************** FORWARD REFERENCES ************************/
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);
 BOOL FAR PASCAL SetRectTestPaint ();
 RECT            NewRect ();

 /******************** WINMAIN -- Main Windows Procedure ***************/
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE          hInstance;
 HANDLE          hPrevInstance;
 LPSTR           lpszCmdLine;
 int             cmdShow;
 {
                 MSG  msg;

         if (!hPrevInstance) {
                 /* ensure that windows know where to find parts of this
                  * task on disk by Registering a window class.  Registering
                  * a class binds an executable name to an internal name,
                  * known to Windows. */
                 WNDCLASS        rClass;

                 rClass.lpszClassName    = (LPSTR)"setrect";
                 rClass.hInstance        = hInstance;
                 rClass.lpfnWndProc      = WindowProc;
                 rClass.hCursor          = LoadCursor (NULL, IDC_ARROW);
                 rClass.hIcon            = LoadIcon (hInstance, (LPSTR)"setrec
                 rClass.lpszMenuName     = (LPSTR) NULL;
     rClass.hbrBackground    = GetStockObject (WHITE_BRUSH);
                 rClass.style            = CS_HREDRAW | CS_VREDRAW;
                 rClass.cbClsExtra       = 0;
                 rClass.cbWndExtra       = 0;

                 RegisterClass ((LPWNDCLASS) &rClass);
                 } /* end if this is the 1st task/instance of this program */

         hWnd = CreateWindow (   (LPSTR) "setrect", /* Window class name */
                                 (LPSTR) "setrect", /* Window title */
                                 WS_OVERLAPPEDWINDOW,
                                         /* stlye -- WIN 2.x or later */
                                 CW_USEDEFAULT,  /* x -  WIN 2.x or later */
                                 CW_USEDEFAULT,  /* y -  WIN 2.x or later */
                                 CW_USEDEFAULT,  /* cx - WIN 2.x or later */
                                 CW_USEDEFAULT,  /* cy - WIN 2.x or later */
                                 (HWND)NULL,     /* No parent */
                                 (HMENU)NULL,    /* Use the class menu */
                                 (HANDLE)hInstance, /* .EXE file for Class */
                                 (LPSTR)NULL     /* No Params */
                              );

   MessageBox (NULL,
     (LPSTR)"This is a demostration of the SetRect Function",
     (LPSTR)"SetRect",
     MB_OK);

         ShowWindow (hWnd, cmdShow);  /* Allocate room for the window  */
         UpdateWindow (hWnd);    /* Paint the client area */

         while (GetMessage ((LPMSG)&msg, NULL, 0, 0)) {
                 TranslateMessage (&msg);
                 DispatchMessage (&msg);
                 } /* end while more messages */
         exit (msg.wParam);
 } /* WINMAIN */
 /***************************** WINDOWPROC *****************************/
 /*      Every message dispatched to any window of type "setrect" will
  *      result in a call to this procedure.
  */
 long FAR PASCAL WindowProc (hWnd, identifier, wParam, lParam)
 HWND            hWnd;           /* Intended window */
 unsigned        identifier;     /* Message Number */
 WORD            wParam;         /* 16 bit param */
 LONG            lParam;         /* 32 bit param */
 {

         switch (identifier) {
     case WM_PAINT:
       SetRectTestPaint ();
       break;
                 default:
                         return (DefWindowProc
                                 (hWnd, identifier, wParam, lParam));
                         break;
                 } /* end switch */
         return (0L);
 } /* windowproc */
 /************************** PAINTING PROCEDURE *****************************/
 /* This function will paint the new rectangle in the client area with a
  * newly created brush. */
 BOOL FAR PASCAL SetRectTestPaint ()
 {
     PAINTSTRUCT     ps;
     RECT            rect;
     HDC             hDC;
     HBRUSH          hBrush;

   hDC = BeginPaint (hWnd, (LPPAINTSTRUCT) &ps);

   /* Create a new brush to paint the new rectangle with */
   hBrush = CreateSolidBrush (RGB (0, 0, 0)); /* BLACK = 0,0,0 */

   rect = NewRect ();      /* get the new rectangle */
   FillRect (hDC, (LPRECT)&rect, hBrush);  /* color rectangle  */

   ValidateRect (hWnd, (LPRECT)NULL);  /* confirm paint  */
   EndPaint (hWnd, (LPPAINTSTRUCT) &ps);
   return TRUE;
 }
 /********************** SET NEW RECTANGLE - SETRECT *********************/
 /* Gets the current coordinates of the client area and returns a
  * smaller rectangle of that will be centered in the client area.
  */
 RECT    NewRect ()
 {
     RECT  rect;
     int     left;
     int     top;
     int     right;
     int     bottom;

   GetClientRect (hWnd, (LPRECT)&rect); /* Get Client Area Coordinates */

   left = rect.left + 15;         /* values for smaller rect. */
   top = rect.top + 15;
   right = rect.right - 15;
   bottom = rect.bottom - 15;

   /* Create new rectangle with the above coordinates
    * into the rect struct */
   SetRect ((LPRECT)&rect, left, top, right, bottom);

   return (rect);
 }


 SETROP2.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SETROP2.C

 /*
  *  SetROP2
  *  setrop2.c
  *
  *  This program demonstrates the use of the function SetROP2.
  *  It sets the current drawing mode of the display context. GDI uses the
  *  drawing mode to combine pens and interior of filled objects with color
  *  already on the display surface. The mode specifies how the color of
  *  the pen or interior and the color already on the display surface are
  *  combined to yield a new color. In this program, a rectangle is drawn on
  *  the client area with different drawing mode. It will show how the pen
  *  (which is used to draw the border) and the brush (which is used to fill
  *  the rectangle) combine with the color already on the screen.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setrop2";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( LTGRAY_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;                 /* Handle to the parent window    */
     HDC   hDC;                  /* Display context of client area */
     MSG   msg;                  /* Window messages                */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setrop2",
                         (LPSTR)"Setting Drawing Mode",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Get a DC before writing to the client area */
     hDC = GetDC (hWnd);

     /* Using the default drawing mode of R2_COPYPEN from the display
      * context, where the pixel is the color of the pen and brush,
      * regardless of what is on the screen
      */
     Rectangle (hDC, 50, 50, 150, 100);
     MessageBox (hWnd, (LPSTR)"The ROP2 is R2_COPYPEN", (LPSTR)"R2_COPYPEN", M

     /* The pixel is always white with R2_WHITE */
     SetROP2 (hDC, R2_WHITE);
     Rectangle (hDC, 60, 60, 160, 110);
     MessageBox (hWnd, (LPSTR)"The ROP2 is R2_WHITE", (LPSTR)"R2_WHITE", MB_OK

     /* The pixel is a combination of colors in the pen/brush and display,
      * but not in both witj R2_XORPEN
      */
     SetROP2 (hDC, R2_XORPEN);
     Rectangle (hDC, 70, 70, 170, 120);
     MessageBox (hWnd, (LPSTR)"The ROP2 is R2_XORPEN", (LPSTR)"R2_XORPEN", MB_

     /* The pixel is the inverse of the display color with R2_NOT */
     SetROP2 (hDC, R2_NOT);
     Rectangle (hDC, 80, 80, 180, 130);
     MessageBox (hWnd, (LPSTR)"The ROP2 is R2_NOT", (LPSTR)"R2_NOT", MB_OK);

     /* return the display context when everything is done */
     ReleaseDC (hWnd, hDC);

     /* Window message loop */
     while (GetMessage ((LPMSG)&msg, NULL, 0, 0))
       {
          TranslateMessage ((LPMSG)&msg);
          DispatchMessage  ((LPMSG)&msg);
       }

     return (int)msg.wParam;
 }


 SETSCPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SETSCPOS.C

 /*
  *  SetScrollPos
  *  setscpos.c
  *
  *  This program demonstrates the use of the function SetScrollPos.
  *  It sets the current position of a scroll bar elevator to a specified
  *  position and redraws the scroll bar to reflect the new position, if
  *  requested.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setscpos";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;                /* Handle to the parent window    */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setscpos",
                         (LPSTR)"Setting Scroll Position",
                         WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Setting up the vertical and horizontal scroll bars range */
     SetScrollRange (hWnd, SB_VERT, 1, 10, (BOOL)TRUE);
     SetScrollRange (hWnd, SB_HORZ, 1, 10, (BOOL)TRUE);

     /* initial position on a vertical scroll bar */
     SetScrollPos   (hWnd, SB_VERT, 2, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"The scroll bar elevator is near the top",
                 (LPSTR)"Vertical", MB_OK);

     /* moved to a new location */
     SetScrollPos (hWnd, SB_VERT, 9, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"Now the scroll bar elevator is set to another l
                 (LPSTR)"Vertical", MB_OK);

     /* initial position on a vertical scroll bar */
     SetScrollPos   (hWnd, SB_HORZ, 2, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"The scroll bar elevator is near the left",
                 (LPSTR)"Horizontal", MB_OK);

     /* moved to a new location */
     SetScrollPos (hWnd, SB_HORZ, 9, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"Now the scroll bar elevator is set to another l
                 (LPSTR)"Horizontal", MB_OK);

     return 0;
 }


 SETSCRNG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SETSCRNG.C

 /*
  *  SetScrollRange
  *  setscpos.c
  *
  *  This program demonstrates the use of the function SetScrollRange.
  *  It sets the minimum and maximum position values for the scroll bar
  *  of a window. If the minimum position equals the maximum position,
  *  then the scroll bar is removed.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Setscrng";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;                /* Handle to the parent window    */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Setscrng",
                         (LPSTR)"Setting Scroll Range",
                         WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Setting up the vertical and horizontal scroll bars range */
     SetScrollRange (hWnd, SB_VERT, 1, 10, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"The new range is set for the vertical scroll ba
                 (LPSTR)"Vertical", MB_OK);

     SetScrollRange (hWnd, SB_HORZ, 1, 20, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"The new range is set for the horizontal scroll
                 (LPSTR)"Horizontal", MB_OK);

     /* removing the vertical scroll bar */
     SetScrollRange (hWnd, SB_VERT, 0, 0, (BOOL)TRUE);
     MessageBox (hWnd, (LPSTR)"The vertical scroll bar is now removed",
                 (LPSTR)"Vertical", MB_OK);

     return 0;
 }


 SETSNDNS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\SETSNDNS.C

 /*
  *  SetSoundNoise
  *  setsndns
  *
  *  SetSoundNoise(nSource, nDuration) sets the source and duration of a
  *  noise in the noise hardware of the play device.  nSource is a short
  *  integer specifying the noise source.  nDuration is a short integer value
  *  specifying the duration of the noise in clock tics.
  *
  *  This program demonstrates the use of the function SetSoundNoise.
  *  As shown below, OpenSound must be invoked before SetSoundNoise can
  *  be called.  SetSoundNoise(nSource, nDuration) returns zero if the
  *  function is successful.  If the source is invalid, it returns S_SERDSR.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;      /* Handle to the parent window */
     short nResult;   /* Contains return value for SetSoundNoise function */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
       (LPSTR)"SetSoundNoise",
                         WS_TILEDWINDOW,
                         20,20,400,200,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the application is activated
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     OpenSound ();   /* Must open access to the play device before
          * SetSoundNoise can be invoked */

     /*********************************************************************/
     /* S_PERIOD512 is the noise source (high pitch hiss).  3000 is the
      * duration of the noise in clock tics. */

     nResult = SetSoundNoise(S_PERIOD512,3000); /* nResult = 0 if successful *

     /*********************************************************************/

     CloseSound();   /* Close access to play device */

     /* return code for SetSoundNoise routine */

     if (nResult==0)
   MessageBox (hWnd, (LPSTR)"SetSoundNoise worked",
        (LPSTR)"Done", MB_OK);

     else if (nResult == S_SERDSR)
   MessageBox (hWnd, (LPSTR)"The noise source parameter is invalid",
        (LPSTR)NULL, MB_OK);

     return 0;
 }


 SETVCQUE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\SETVCQUE.C

 /*
  *  SetVoiceQueueSize
  *  setvcque
  *
  *  SetVoiceQueueSize(nVoice,nBytes) allocates nBytes bytes for the voice
  *  queue specified by nVoice.  If the queue size is not set, the default
  *  is 192 bytes, room for about 32 notes.  All voice queues are locked in
  *  memory.  The queues cannot be set while music is playing.
  *
  *  This program demonstrates the use of the function SetVoiceQueueSize.
  *  As shown below, OpenSound must be invoked before SetVoiceQueueSize can
  *  be called.  SetVoiceQueueSize returns one of three possible values -
  *  one success value and two error values.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;             /* Handle to the parent window            */
     short nResult;          /* Returned by SetVoiceQueueSize function */
     short nVoice;           /* Specifies the voice queue              */
     short nVoices;          /* Specifies the number of voices available */
     short nBytes;           /* Specifies the number of bytes to be
                              * allocated to the voice queue           */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
                         (LPSTR)"SetVoiceQueueSize",
                         WS_TILEDWINDOW,
                         20,20,400,200,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the application is activated
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );
     /*********************************************************************/

     nVoices = OpenSound ();   /* Must open access to the play device before
              * SetVoiceQueueSize can be invoked */

     /* Allocate nBytes for the voice queue specified by nVoice */
     nVoice = 1;
     nBytes = 300;   /* Default is 192 bytes, room for about 32 notes */
     nResult = SetVoiceQueueSize (nVoice, nBytes);
      /* The return value is zero if the function is successful.  On error
       * it is one of the following:
       *      S_SEROFM  Out of memory
       *      S_SERMACT  Music active   */

     CloseSound(); /* CloseSound must be invoked to allow other applications
        * access to the play device */

     /*********************************************************************/
     /* return code for SetVoiceQueueSize routine */
     if (nResult == 0)                           /* Function is successful */
       {  MessageBox (hWnd, (LPSTR)"300 bytes are allocated to voice queue num
                     (LPSTR)"Done", MB_OK);
       }
     else if (nResult == S_SEROFM)     /* If nResult == S_SERTOFM then out of
       {  MessageBox (hWnd, (LPSTR)"Out of memory",
                     (LPSTR)NULL, MB_OK);
       }
     else
       {  MessageBox (hWnd, (LPSTR)"Music active", /* If nResult = S_SERMACT t
                     (LPSTR)NULL, MB_OK);
       }
     return 0;
 }


 SETVIEW.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SETVIEW.C

 /*
  *  SetViewportExt
  *  setview.c
  *
  *  This function demonstrates the use of the SetViewportExt function.  It wi
  *  create a window, and procede to draw a triangle in the window in
  *  the MM_ANISOTROPIC mapping mode.
  *
  */

 #include <windows.h>

 /* Forward Declarations  */

 BOOL FAR PASCAL InitSetViewportExt ( HANDLE , HANDLE , int );
 long FAR PASCAL SetViewportExtWindowProc ( HANDLE , unsigned , WORD , LONG );

 /*
  *  MAIN PROCEDURE
  */

 int PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , cmdShow )

 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int cmdShow;
   {
   MSG  msg;          /*  Temp buffer to hold message  */

   InitSetViewportExt (hInstance, hPrevInstance, cmdShow );  /*  Init Routine

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);     /*  Give Your windowproc the  */
     }              /*  message        */

   exit(msg.wParam);
   }

 BOOL FAR PASCAL InitSetViewportExt (hInstance , hPrevInstance , cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int cmdShow;

   {
   WNDCLASS  wcSetViewportExtClass;
   HWND  hWnd;

   wcSetViewportExtClass.lpszClassName = (LPSTR) "SetViewportExt";
   wcSetViewportExtClass.hInstance     = hInstance;
   wcSetViewportExtClass.lpfnWndProc   = SetViewportExtWindowProc;
   wcSetViewportExtClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
   wcSetViewportExtClass.hIcon        = NULL;
   wcSetViewportExtClass.lpszMenuName  = (LPSTR) NULL;
   wcSetViewportExtClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcSetViewportExtClass.style        = CS_HREDRAW | CS_VREDRAW;
   wcSetViewportExtClass.cbClsExtra    = 0;
   wcSetViewportExtClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) &wcSetViewportExtClass);

   hWnd = CreateWindow((LPSTR) "SetViewportExt",   /*  Window class name
           (LPSTR) "SetViewportExt",   /*  Window title        */
           WS_OVERLAPPEDWINDOW,  /*  Type of window    */
           CW_USEDEFAULT,      /*  x      */
           CW_USEDEFAULT,      /*  y      */
           CW_USEDEFAULT,      /*  cx      */
           CW_USEDEFAULT,      /*  cy      */
           (HWND)NULL,      /*  No parent for this wind */
           (HMENU)NULL,      /*  Use the Class menu  */
           (HANDLE)hInstance,    /*  Who created this window */
           (LPSTR)NULL      /*  No params. to pass on.  */
          );

   ShowWindow (hWnd , cmdShow);   /*  Display this window on the screen  */
   UpdateWindow (hWnd);     /*  Cause a paint message    */

   return TRUE;
   }

 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long FAR PASCAL SetViewportExtWindowProc (hWnd , message , wParam , lParam)

 HWND      hWnd;        /*  Handle of the window  */
 unsigned    message;        /*  Message type    */
 WORD      wParam;        /*  Message 16-bit param  */
 LONG      lParam;        /*  Message 32-bit param  */
   {
   switch (message)        /*  Check the message type  */
     {
     case WM_PAINT:        /*  Process the Paint  */
   PaintSetViewportExtWindow (hWnd); /*  message          */
   break;

     case WM_DESTROY:        /*  If close requested  */
   PostQuitMessage(0);      /*    send yourself a quit  */
   break;          /*    message    */

     default:
   return( DefWindowProc( hWnd , message , wParam , lParam ) );
   break;
     }
   return( 0L );
   }

 /*
  *  THE PAINT PROCEDURE
  */

 PaintSetViewportExtWindow (hWnd)

 HWND  hWnd;             /*  Handle of the window  */
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE  hOldBrush , hBrush;        /*  For loading new brushes  */
   RECT    rRect;            /*  Will hold the client     */
                 /*  Rectangle       */

   BeginPaint (hWnd , (LPPAINTSTRUCT) &ps);    /*  Prepare the client area  */
   hDC = ps.hdc;             /*  Get the Display Context  */

   hBrush = GetStockObject ( GRAY_BRUSH );     /*  Get a gray brush     */
   hOldBrush = SelectObject ( hDC , hBrush );  /*  Select the new brush     */

   lpTriangle[0].x = 150;    /*  The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode ( hDC , MM_ANISOTROPIC );   /*  Set the mapping mode        */

   SetWindowExt ( hDC , 300 , 300 );   /*  Set the extent of the drawing
             *  area.  This is the area that
             *  holds graphics that you create
             *  with GDI functions.  Do not
             *  confuse this function with
             *  the actual window.  The
             *  SetViewportExt sets the
             *  extent of the area to be mapped
             *  to which is the actual window
             */

   GetClientRect ( hWnd , (LPRECT) &rRect );
            /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt ( hDC , rRect.right , rRect.bottom );
            /*  Set the Extent of the viewport   */

   Polygon ( hDC , lpTriangle , 3 );   /*  Draw the triangle          */

   ValidateRect (hWnd , (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) &ps );

   SelectObject( hDC , hOldBrush );   /*  Replace the old brush  */
   return TRUE;
   }


 SETWINEX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\SETWINEX.C

 /*
  *  SetWindowExt
  *  setwinex.c
  *
  *  This function demonstrates the use of the SetWindowExt function.  It will
  *  create a window, and procede to draw a triangle in the window in
  *  the MM_ANISOTROPIC mapping mode.
  *
  */

 #include <windows.h>

 /* Forward Declarations  */

 BOOL FAR PASCAL InitSetWindowExt ( HANDLE , HANDLE , int );
 long FAR PASCAL SetWindowExtWindowProc ( HANDLE , unsigned , WORD , LONG );

 /*
  *  MAIN PROCEDURE
  */

 int PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , cmdShow )

 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int cmdShow;
   {
   MSG  msg;          /*  Temp buffer to hold message  */

   InitSetWindowExt (hInstance, hPrevInstance, cmdShow );  /*  Init Routine  *

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);     /*  Give Your windowproc the  */
     }              /*  message        */

   exit(msg.wParam);
   }

 BOOL FAR PASCAL InitSetWindowExt (hInstance , hPrevInstance , cmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int cmdShow;

   {
   WNDCLASS  wcSetWindowExtClass;
   HWND  hWnd;

   wcSetWindowExtClass.lpszClassName = (LPSTR) "SetWindowExt";
   wcSetWindowExtClass.hInstance     = hInstance;
   wcSetWindowExtClass.lpfnWndProc   = SetWindowExtWindowProc;
   wcSetWindowExtClass.hCursor      = LoadCursor ( NULL , IDC_ARROW );
   wcSetWindowExtClass.hIcon      = NULL;
   wcSetWindowExtClass.lpszMenuName  = (LPSTR) NULL;
   wcSetWindowExtClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcSetWindowExtClass.style      = CS_HREDRAW | CS_VREDRAW;
   wcSetWindowExtClass.cbClsExtra    = 0;
   wcSetWindowExtClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) &wcSetWindowExtClass);

   hWnd = CreateWindow((LPSTR) "SetWindowExt",  /*  Window class name      */
           (LPSTR) "SetWindowExt",  /*  Window title      */
           WS_OVERLAPPEDWINDOW,  /*  Type of window    */
           CW_USEDEFAULT,      /*  x      */
           CW_USEDEFAULT,      /*  y      */
           CW_USEDEFAULT,      /*  cx      */
           CW_USEDEFAULT,      /*  cy      */
           (HWND)NULL,      /*  No parent for this wind */
           (HMENU)NULL,      /*  Use the Class menu  */
           (HANDLE)hInstance,    /*  Who created this window */
           (LPSTR)NULL      /*  No params. to pass on.  */
          );

   ShowWindow (hWnd , cmdShow);   /*  Display this window on the screen  */
   UpdateWindow (hWnd);     /*  Cause a paint message    */

   return TRUE;
   }

 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long FAR PASCAL SetWindowExtWindowProc (hWnd , message , wParam , lParam)

 HWND      hWnd;        /*  Handle of the window  */
 unsigned    message;        /*  Message type    */
 WORD      wParam;        /*  Message 16-bit param  */
 LONG      lParam;        /*  Message 32-bit param  */
   {
   switch (message)        /*  Check the message type  */
     {
     case WM_PAINT:        /*  Process the Paint  */
   PaintSetWindowExtWindow (hWnd); /*  message        */
   break;

     case WM_DESTROY:        /*  If close requested  */
   PostQuitMessage(0);      /*    send yourself a quit  */
   break;          /*    message    */

     default:
   return( DefWindowProc( hWnd , message , wParam , lParam ) );
   break;
     }
   return( 0L );
   }

 /*
  *  THE PAINT PROCEDURE
  */

 PaintSetWindowExtWindow (hWnd)

 HWND  hWnd;             /*  Handle of the window  */
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE  hOldBrush , hBrush;        /*  For loading new brushes  */
   RECT    rRect;            /*  Will hold the client     */
                 /*  Rectangle       */

   BeginPaint (hWnd , (LPPAINTSTRUCT) &ps);    /*  Prepare the client area  */
   hDC = ps.hdc;             /*  Get the Display Context  */

   hBrush = GetStockObject ( GRAY_BRUSH );     /*  Get a gray brush     */
   hOldBrush = SelectObject ( hDC , hBrush );  /*  Select the new brush     */

   lpTriangle[0].x = 150;    /*  The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode ( hDC , MM_ANISOTROPIC );   /*  Set the mapping mode        */

   SetWindowExt ( hDC , 300 , 300 );   /*  Set the extent of the drawing
             *  area.  This is the area that
             *  holds graphics that you create
             *  with GDI functions.  Do not
             *  confuse this function with
             *  the actual window.  The
             *  SetViewportExt sets the
             *  extent of the area to be mapped
             *  to which is the actual window
             */

   GetClientRect ( hWnd , (LPRECT) &rRect );
            /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt ( hDC , rRect.right , rRect.bottom );
            /*  Set the Extent of the viewport   */

   Polygon ( hDC , lpTriangle , 3 );   /*  Draw the triangle          */

   ValidateRect (hWnd , (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) &ps );

   SelectObject( hDC , hOldBrush );   /*  Replace the old brush  */
   return TRUE;
   }


 SETWL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CLASS\SETWL.C

 /*

 Function(s) demonstrated in this program: SetWindowLong

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:   This function replaces the long value in the window class
    structure corresponding to the window handle parameter, with the
    respective new value.

 Additional Comments:  This program requests 4 extra bytes when it registers
    its window structure.  These 4 extra bytes are used to store a long
    value corresponding to the number of left mouse button clicks.
    This value is updated using GetWindowLong and SetWindowLong.


 */

 #define NOMINMAX
 #include <stdlib.h>
 #include <windows.h>
 #include "SetWl.h"
 #include "string.h"
 #include "stdio.h"

        char         szAppName             [] = "SetWl"             ;
        HANDLE       hInstMain                                      ;
        HWND         hWndMain                                       ;
        char         szOutputBuffer1       [70]                     ;
        char         szOutputBuffer2       [500]                    ;
        HBITMAP      hBitmapHelp                                    ;


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use  of  the  SetWindowLong  Windows function.",

 "Help Message",
 "     This program uses GetWindowLong and\n\
 SetWindowLong to keep track of the number of left\n\
 button mouse click message.  A message box shows\n\
 how many every time one is sent.  Click the left\n\
 mouse button to test this function.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;
     LONG    WindowCount;


     if (!hPrevInstance)
   {
   wndclass.style           = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
   wndclass.lpfnWndProc    = WndProc;
   wndclass.cbClsExtra     = 0;
   wndclass.cbWndExtra     = 4;
   wndclass.hInstance      = hInstance;
   wndclass.hIcon           = NULL;
    wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = szAppName;
   wndclass.lpszClassName  = szAppName;

     if (!RegisterClass (&wndclass) )
         return FALSE;
     }

     hWnd = CreateWindow (szAppName, "SetWindowLong",
            WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
            NULL, NULL, hInstance, NULL);

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

     while (GetMessage (&msg, NULL, 0, 0))
         {
         TranslateMessage (&msg);
         DispatchMessage (&msg);
         }
     return msg.wParam;
 }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
    HWND      hWnd;
    unsigned  iMessage;
    WORD      wParam;
    LONG      lParam;
    {
    HMENU     hMenu;

    switch (iMessage)
        {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             break;

        case WM_LBUTTONUP:
             SetWindowLong (hWnd, 0, GetWindowLong (hWnd, 0) + 1);
             sprintf (szOutputBuffer1,
                      "Number of left mouse button double clicks = %i",
                       GetWindowLong (hWnd, 0));
             MessageBox (hWnd, szOutputBuffer1, "SetWindowLong", MB_OK);
             break;

        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
             break;


        case WM_COMMAND:
             switch (wParam) {
                case IDM_HELP:
                     ProcessMessage (hWnd, 2);
                     break;
            }
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }



 SETWNPOS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\SETWNPOS.C

 /*
  *   SetWindowPos
  *   setwnpos.c
  *
  *   This function changes the size, position, and ordering of child,
  *   popup, and top-level windows.  Child, pop-up, and top-level windows
  *   are ordered according to their appearance on the screen; the topmost
  *   window receives the highest rank, and it is the first window in the
  *   list.  This ordering is recorded in a window list.
  *
  */

 #include "windows.h"

 /* Forward references */

 BOOL FAR PASCAL SetWnPosInit( HANDLE );

 long FAR PASCAL SetWnPosWndProc(HWND, unsigned, WORD, LONG);

 /* ---------------------------------------------------------------------- */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, CmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int CmdShow;
 {
     MSG   msg;
     HWND  hParent, hPopup;
     HMENU hMenu;

     SetWnPosInit( hInstance );
     hParent = CreateWindow((LPSTR)"ShowOwnedPopups",
       (LPSTR)"ShowOwnedPopups",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
          (HWND)NULL,        /* no parent */
          (HMENU)NULL,       /* use class menu */
          (HANDLE)hInstance, /* handle to window instance */
          (LPSTR)NULL        /* no params to pass on */
          );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hParent, CmdShow );
     UpdateWindow( hParent );

 /* Create the popup window */

     hPopup = CreateWindow((LPSTR)"ShowOwnedPopups",
                        (LPSTR)"Popup",
                         WS_POPUP|WS_CAPTION|WS_VISIBLE,
                       50,
                       50,
                       200,
                       100,
                          (HWND)hParent,     /* parent */
                          (HMENU)NULL,       /* use class menu */
                          (HANDLE)hInstance, /* handle to window instance */
                          (LPSTR)NULL        /* no params to pass on */
                         );
 /****************************************************************************
 /* Begin SetWindowPos */
 /* I am about to move and resize the parent window */

     MessageBox (hParent, (LPSTR)"Move and resize the SetWindowPos window",
                (LPSTR)"I'm about to ...", MB_OK);
     SetWindowPos(hParent, hPopup, 100, 100, 200, 200, SWP_NOACTIVATE);

 /* End of SetWindowPos section */
 /****************************************************************************

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* ---------------------------------------------------------------------- */
 /* Procedure called when the application is loaded for the first time */

 BOOL FAR PASCAL SetWnPosInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pSetWnPosClass;

     pSetWnPosClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pSetWnPosClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pSetWnPosClass->hIcon          = LoadIcon( hInstance,NULL);
     pSetWnPosClass->lpszMenuName   = (LPSTR)NULL;
     pSetWnPosClass->lpszClassName  = (LPSTR)"ShowOwnedPopups";
     pSetWnPosClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pSetWnPosClass->hInstance      = hInstance;
     pSetWnPosClass->style          = CS_HREDRAW | CS_VREDRAW;
     pSetWnPosClass->lpfnWndProc    = SetWnPosWndProc;

     if (!RegisterClass( (LPWNDCLASS)pSetWnPosClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pSetWnPosClass );
     return TRUE;        /* Initialization succeeded */
 }


 /* ---------------------------------------------------------------------- */
 /* Every message for this window will be delevered right here.         */

 long FAR PASCAL SetWnPosWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

 /*    case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break; */

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 SETWNTXT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\SETWNTXT.C

 /*
  *  SetWindowText
  *  setwntxt.c
  *
  *  This program demonstrates the use of the function SetWindowText.
  *  First a message box is shown which says that the window text caption
  *  is about to change.  After the caption changes then a message box pops
  *  up which gives the user a chance to look at the change.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;         /* Handle to the parent window  */
     HDC   hDC;          /* Handle to the display context of client area */
     char szBuffer[80];        /* Contains the new caption title */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
       (LPSTR)"SetWindowText",  /* Window caption title */
                         WS_TILEDWINDOW,
                         20,20,400,200,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow (hWnd, cmdShow);
     UpdateWindow (hWnd);

     MessageBox (hWnd, (LPSTR)"Press ENTER to change the caption title",
     (LPSTR)"Done", MB_OK);
     sprintf (szBuffer,"%s","New Caption Title to demonstrate SetWindowText");
 /**************************************************************************/
 /* This function will set the window caption title to the string pointed
  * to by szBuffer.  SetWindowText has no return value. */

     SetWindowText (hWnd, (LPSTR)szBuffer);

 /**************************************************************************/

     MessageBox (hWnd, (LPSTR)"The caption title has been changed",
     (LPSTR)"Done", MB_OK);

     return 0;
 }


 SETWNWRD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\SETWNWRD.C

 /*
  *   SetWindowWord
  *   setwnwrd.c
  *
  *   This program demonstrates the use of the function SetWindowWord.
  *   SetWindowWord changes an attribute of a window.  The attribute
  *   can be one of the following options: the instance handle of the
  *   module that owns the window, the window handle of the parent window
  *   if one exists, the control ID of the child window.
  *
  */

 #include "windows.h"

 /* Forward references */

 BOOL FAR PASCAL SampleInit( HANDLE );

 long FAR PASCAL SampleWndProc(HWND, unsigned, WORD, LONG);

 /* ---------------------------------------------------------------------- */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, CmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int CmdShow;
 {
     MSG   msg;
     HWND  hParent1, hParent2, hPopup;
     HMENU hMenu;

     SampleInit( hInstance );

 /* Create the first parent window */

     hParent1 = CreateWindow((LPSTR)"SetWindowWord",
       (LPSTR)"SetWindowWord - Parent1",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       400,
        20,
          (HWND)NULL,        /* no parent */
          (HMENU)NULL,       /* use class menu */
          (HANDLE)hInstance, /* handle to window instance */
          (LPSTR)NULL        /* no params to pass on */
          );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hParent1, CmdShow );
     UpdateWindow( hParent1 );

     MessageBox (hParent1, (LPSTR)"create a popup window for parent1",
                (LPSTR)"I'm about to ...", MB_OK);

 /* Create the popup window */

     hPopup = CreateWindow((LPSTR)"SetWindowWord",
                        (LPSTR)"Popup",
                         WS_POPUP|WS_CAPTION|WS_VISIBLE,
                       10,
                       50,
                       200,
                       100,
                          (HWND)hParent1,     /* parent */
                          (HMENU)NULL,       /* use class menu */
                          (HANDLE)hInstance, /* handle to window instance */
                          (LPSTR)NULL        /* no params to pass on */
                         );


     MessageBox (hParent1, (LPSTR)"create a second window called parent2",
                (LPSTR)"I'm about to ...", MB_OK);

 /* Create the second parent window */

     hParent2 = CreateWindow((LPSTR)"SetWindowWord",
       (LPSTR)"SetWindowWord - Parent2",
       WS_OVERLAPPEDWINDOW,
       100,
       100,
       400,
       20,
          (HWND)NULL,        /* no parent */
          (HMENU)NULL,       /* use class menu */
          (HANDLE)hInstance, /* handle to window instance */
          (LPSTR)NULL        /* no params to pass on */
          );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hParent2, CmdShow );
     UpdateWindow( hParent2 );

 /****************************************************************************
 /* Begin SetWindowWord */
 /* I have set up this function to change the parent of the popup window */

     MessageBox (hParent1, (LPSTR)"make the Parent2 the parent of Popup, and \
 iconize Parent1.  Notice that Parent2 is currently in front of Popup .",
                (LPSTR)"I'm about to ...", MB_OK);

     SetWindowWord(hPopup, GWW_HWNDPARENT, hParent2);
     ShowWindow( hParent1, SW_SHOWMINIMIZED );

     MessageBox (hParent1, (LPSTR)"move Parent2 in front of the Popup.  \
 You can't do it because Parent2 is now the parent of Popup!",
                (LPSTR)"Now try to ...", MB_OK);

 /* End of SetWindowWord section */
 /****************************************************************************

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* ---------------------------------------------------------------------- */
 /* Procedure called when the application is loaded for the first time */

 BOOL FAR PASCAL SampleInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pSampleClass;

     pSampleClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pSampleClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pSampleClass->hIcon          = LoadIcon( hInstance,NULL);
     pSampleClass->lpszMenuName   = (LPSTR)NULL;
     pSampleClass->lpszClassName  = (LPSTR)"SetWindowWord";
     pSampleClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pSampleClass->hInstance      = hInstance;
     pSampleClass->style          = CS_HREDRAW | CS_VREDRAW;
     pSampleClass->lpfnWndProc    = SampleWndProc;

     if (!RegisterClass( (LPWNDCLASS)pSampleClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pSampleClass );
     return TRUE;        /* Initialization succeeded */
 }


 /* ---------------------------------------------------------------------- */
 /* Every message for this window will be delevered right here.         */

 long FAR PASCAL SampleWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

 /*    case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break; */

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 SHOWCURS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CURSOR\SHOWCURS.C

 /*
 Function(s) demonstrated in this program:  ShowCursor

 Compiler version:  5.10

 Description:  Use ShowCursor to hide the cursor each time the right mouse
         button is pressed, and display it again when the button is
         released.

 Additional Comments:



 ****************************************************************************/

 #include <windows.h>

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "SampleWindow" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG   msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor   = LoadCursor (NULL, IDC_CROSS);
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
         "Using the ShowCursor function",  /* window caption    */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG   lParam ;
     {
     PAINTSTRUCT ps;
     HDC   hDC;
     switch(iMessage)
   {
   case WM_CREATE:
       {
       break;
       }
   case WM_PAINT:
       {
       hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
       EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
       break;
       }
   case WM_RBUTTONDOWN:
       {
       ShowCursor(0);
       break;
       }
   case WM_RBUTTONUP:
       {
       ShowCursor(1);
       break;
       }
   case WM_DESTROY:
       {
       PostQuitMessage(0);
       break;
       }
   default:
       {
       return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
       }
   }
     return (0L);
     }


 SHOWPOPS.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\SHOWPOPS.C

 /*
  *   ShowOwnedPopups
  *   showpops.c
  *
  *   This program demonstrates the use of the function ShowOwnedPopups.
  *   A pop-up window is initially shown visible.   At the same time a
  *   message box appears.  When the message box is acknowledged then
  *   the pop-up window becomes invisible.  Another message box appears.
  *   When the second message box is acknowledged then the pop-up window
  *   becomes visible again.
  *
  */

 #include "windows.h"

 /* Forward references */

 BOOL FAR PASCAL SampleInit( HANDLE );

 long FAR PASCAL SampleWndProc(HWND, unsigned, WORD, LONG);

 /* ---------------------------------------------------------------------- */

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, CmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int CmdShow;
 {
     MSG   msg;
     HWND  hParent,hPopup;
     HMENU hMenu;

     SampleInit( hInstance );
     hParent = CreateWindow((LPSTR)"ShowOwnedPopups",
       (LPSTR)"ShowOwnedPopups",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
          (HWND)NULL,        /* no parent */
          (HMENU)NULL,       /* use class menu */
          (HANDLE)hInstance, /* handle to window instance */
          (LPSTR)NULL        /* no params to pass on */
          );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hParent, CmdShow );
     UpdateWindow( hParent );

 /* Create the popup window */

     hPopup = CreateWindow((LPSTR)"ShowOwnedPopups",
                        (LPSTR)"Popup",
                         WS_POPUP|WS_CAPTION|WS_VISIBLE,
                       50,
                       50,
                       200,
                       100,
                          (HWND)hParent,     /* parent */
                          (HMENU)NULL,       /* use class menu */
                          (HANDLE)hInstance, /* handle to window instance */
                          (LPSTR)NULL        /* no params to pass on */
                         );
 /****************************************************************************
 /* Begging of ShowOwnedPopups section */

 /* void ShowOwnedPopups( hWnd, fShow )
  *
  * The first parameter 'hWnd' is the handle to the parent window that
  * owns the pop-up.  The second parameter 'fShow' is nonzero if all
  * hidden pop-up windows should be shown; it is zero if all visible
  * pop-up windows should be hidden                                          *

     MessageBox (hParent, (LPSTR)"Hide the popup.",
                (LPSTR)"Done", MB_OK);

     ShowOwnedPopups(hParent,FALSE);                /* Hide the popup */

     MessageBox (hParent, (LPSTR)"Show the popup.",
              (LPSTR)"Done", MB_OK);

     ShowOwnedPopups(hParent,TRUE);                /* Show the popup */

 /* End of ShowOwnedPopups section */
 /****************************************************************************

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* ---------------------------------------------------------------------- */
 /* Procedure called when the application is loaded for the first time */

 BOOL FAR PASCAL SampleInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pSampleClass;

     pSampleClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pSampleClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pSampleClass->hIcon          = LoadIcon( hInstance,NULL);
     pSampleClass->lpszMenuName   = (LPSTR)NULL;
     pSampleClass->lpszClassName  = (LPSTR)"ShowOwnedPopups";
     pSampleClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pSampleClass->hInstance      = hInstance;
     pSampleClass->style          = CS_HREDRAW | CS_VREDRAW;
     pSampleClass->lpfnWndProc    = SampleWndProc;

     if (!RegisterClass( (LPWNDCLASS)pSampleClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pSampleClass );
     return TRUE;        /* Initialization succeeded */
 }


 /* ---------------------------------------------------------------------- */
 /* Every message for this window will be delevered right here.         */

 long FAR PASCAL SampleWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

 /*    case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break; */

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 SHOWSB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SCROLL\SHOWSB.C

 /*

 Function(s) demonstrated in this program: ShowScrollBar

 Description:  This function displays or hides a scroll bar, depending on the
    value of the the parameters.

 */

 #include <windows.h>
 #include <stdio.h>
 #include "ShowSB.h"
 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];

 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample  application to demonstrate\n\
 the use of the ShowScrollBar Windows function.",

 "Help Message",
 "     This program uses the ShowScrollBar Windows\n\
 function to change status of the Scroll bars of the\n\
 window.  Use the menu to choose the status (show or\n\
 hide)."

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE   hInstance, hPrevInstance ;
      LPSTR    lpszCmdLine ;
      int      nCmdShow ;
      {
      WNDCLASS wndclass ;
      HWND     hWnd ;
      MSG      msg ;
      static   char szAppName [] = "ShowSB" ;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName, "Show Scroll Bar",
                          WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
                          CW_USEDEFAULT, 0,
                          CW_USEDEFAULT, 0,
                          NULL, NULL, hInstance, NULL) ;

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

      while (GetMessage (&msg, NULL, 0, 0))
           {
           TranslateMessage (&msg) ;
           DispatchMessage (&msg) ;
           }
      return msg.wParam ;
      }

 /****************************************************************************


 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
      HWND         hWnd ;
      unsigned     iMessage ;
      WORD         wParam ;
      LONG         lParam ;
      {
      PAINTSTRUCT  ps ;
      HMENU        hMenu;

      switch (iMessage)
           {
           case WM_CREATE:
                hMenu = GetSystemMenu (hWnd, FALSE);
                ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                            MF_APPEND | MF_STRING);
                break ;

           case WM_SYSCOMMAND:
                switch (wParam) {
                   case IDM_ABOUT:
                        ProcessMessage (hWnd, 0);
                        break;
                   default:
                        return DefWindowProc (hWnd, iMessage, wParam, lParam)
                }
                break;

           case WM_COMMAND:
                switch (wParam) {
                   case IDM_ABOUT:
                        ProcessMessage (hWnd, 0);
                        break;

                   case IDM_SHOW:
                        ShowScrollBar (hWnd, SB_BOTH, TRUE);
                        break;

                   case IDM_HIDE:
                        ShowScrollBar (hWnd, SB_BOTH, FALSE);
                        break;

                   case IDM_HELP:
                        ProcessMessage (hWnd, 2);
                        break;
                }
                break;

           case WM_PAINT:
                BeginPaint (hWnd, &ps) ;
                EndPaint (hWnd, &ps) ;
                break ;

           case WM_DESTROY:
                PostQuitMessage (0) ;
                break ;

           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
           }
      return 0L ;
      }


 SHOWWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\WINDOW\SHOWWIN.C

 /*
  *  ShowWindow
  *  showwin.c
  *
  *  This function demonstrates the use of the ShowWindow function.  It will
  *  create a window, show the window using the ShowWindow command and procede
  *  to draw a triangle in the window in the MM_ANISOTROPIC mapping mode.
  *
  */

 #include <windows.h>

 /* Forward Declarations  */

 BOOL FAR PASCAL InitShowWindow ( HANDLE , HANDLE , int );
 long FAR PASCAL ShowWindowWindowProc ( HANDLE , unsigned , WORD , LONG );

 /*
  *  MAIN PROCEDURE
  */

 int PASCAL WinMain  (hInstance , hPrevInstance , lpszCmdLine , nCmdShow )

 HANDLE hInstance , hPrevInstance;
 LPSTR  lpszCmdLine;
 int nCmdShow;
   {
   MSG  msg;          /*  Temp buffer to hold message  */

   InitShowWindow (hInstance, hPrevInstance, nCmdShow );  /*  Init Routine  */

   while ( GetMessage((LPMSG)&msg, NULL, 0 , 0 ))
     {
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);     /*  Give Your windowproc the  */
     }              /*  message        */

   exit(msg.wParam);
   }

 BOOL FAR PASCAL InitShowWindow (hInstance , hPrevInstance , nCmdShow)

 HANDLE hInstance;
 HANDLE hPrevInstance;
 int nCmdShow;

   {
   WNDCLASS  wcShowWindowClass;
   HWND  hWnd;

   wcShowWindowClass.lpszClassName = (LPSTR) "ShowWindow";
   wcShowWindowClass.hInstance    = hInstance;
   wcShowWindowClass.lpfnWndProc   = ShowWindowWindowProc;
   wcShowWindowClass.hCursor    = LoadCursor ( NULL , IDC_ARROW );
   wcShowWindowClass.hIcon    = NULL;
   wcShowWindowClass.lpszMenuName  = (LPSTR) NULL;
   wcShowWindowClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcShowWindowClass.style    = CS_HREDRAW | CS_VREDRAW;
   wcShowWindowClass.cbClsExtra    = 0;
   wcShowWindowClass.cbWndExtra    = 0;

   RegisterClass ((LPWNDCLASS) &wcShowWindowClass);

   hWnd = CreateWindow((LPSTR) "ShowWindow",   /*  Window class name    */
           (LPSTR) "ShowWindow",   /*  Window title      */
           WS_OVERLAPPEDWINDOW,  /*  Type of window    */
           CW_USEDEFAULT,      /*  x      */
           CW_USEDEFAULT,      /*  y      */
           CW_USEDEFAULT,      /*  cx      */
           CW_USEDEFAULT,      /*  cy      */
           (HWND)NULL,      /*  No parent for this wind */
           (HMENU)NULL,      /*  Use the Class menu  */
           (HANDLE)hInstance,    /*  Who created this window */
           (LPSTR)NULL      /*  No params. to pass on.  */
          );

   ShowWindow (hWnd , nCmdShow);   /*  Display this window on the screen
            *  nCmdShow is passed in by WinMain, and
            *  should only be used with ShowWindow
            *  once during a program.  Any further
            *  calls to ShowWindow will need to have
            *  certain values.  See entry in manual
            *  for ShowWindow for further details
            */

   UpdateWindow (hWnd);     /*  Cause a paint message    */

   return TRUE;
   }

 /*
  *  THE WINDOW PROCEDURE - Process messages
  */

 long FAR PASCAL ShowWindowWindowProc (hWnd , message , wParam , lParam)

 HWND      hWnd;        /*  Handle of the window  */
 unsigned    message;        /*  Message type    */
 WORD      wParam;        /*  Message 16-bit param  */
 LONG      lParam;        /*  Message 32-bit param  */
   {
   switch (message)        /*  Check the message type  */
     {
     case WM_PAINT:        /*  Process the Paint  */
   PaintShowWindowWindow (hWnd); /*  message      */
   break;

     case WM_DESTROY:        /*  If close requested  */
   PostQuitMessage(0);      /*    send yourself a quit  */
   break;          /*    message    */

     default:
   return( DefWindowProc( hWnd , message , wParam , lParam ) );
   break;
     }
   return( 0L );
   }

 /*
  *  THE PAINT PROCEDURE
  */

 PaintShowWindowWindow (hWnd)

 HWND  hWnd;             /*  Handle of the window  */
   {
   PAINTSTRUCT  ps;
   HDC    hDC;
   POINT   lpTriangle[4];
   HANDLE  hOldBrush , hBrush;        /*  For loading new brushes  */
   RECT    rRect;            /*  Will hold the client     */
                 /*  Rectangle       */

   BeginPaint (hWnd , (LPPAINTSTRUCT) &ps);    /*  Prepare the client area  */
   hDC = ps.hdc;             /*  Get the Display Context  */

   hBrush = GetStockObject ( GRAY_BRUSH );     /*  Get a gray brush     */
   hOldBrush = SelectObject ( hDC , hBrush );  /*  Select the new brush     */

   lpTriangle[0].x = 150;    /*  The values of the points  */
   lpTriangle[0].y = 100;
   lpTriangle[1].x = 100;
   lpTriangle[1].y = 200;
   lpTriangle[2].x = 200;
   lpTriangle[2].y = 200;

   SetMapMode ( hDC , MM_ANISOTROPIC );   /*  Set the mapping mode        */

   SetWindowExt ( hDC , 300 , 300 );   /*  Set the extent of the drawing
             *  area.  This is the area that
             *  holds graphics that you create
             *  with GDI functions.  Do not
             *  confuse this function with
             *  the actual window.  The
             *  SetViewportExt sets the
             *  extent of the area to be mapped
             *  to which is the actual window
             */

   GetClientRect ( hWnd , (LPRECT) &rRect );
            /*  Get the size of the client area
             *  so that we can set the viewport
             *  extent
             */

   SetViewportExt ( hDC , rRect.right , rRect.bottom );
            /*  Set the Extent of the viewport   */

   Polygon ( hDC , lpTriangle , 3 );   /*  Draw the triangle          */

   ValidateRect (hWnd , (LPRECT) NULL);   /*  Disable any more paint messages
   EndPaint (hWnd, (LPPAINTSTRUCT) &ps );

   SelectObject( hDC , hOldBrush );   /*  Replace the old brush  */
   return TRUE;
   }


 SHWCARET.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\CARET\SHWCARET.C

 /*
  *  ShowCaret
  *  shwcaret.c
  *
  *  This program demonstrates the use of the function ShowCaret.
  *  This function shows the system caret on the display at the
  *  caret's current position.  Once shown, the caret begins flashing
  *  automatically.
  *
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pClass;

     pClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     /* registering the parent window class */
     pClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pClass->lpszMenuName   = (LPSTR)NULL;
     pClass->lpszClassName  = (LPSTR)"Window";
     pClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pClass->hInstance      = hInstance;
     pClass->style          = CS_HREDRAW | CS_VREDRAW;
     pClass->lpfnWndProc    = DefWindowProc;

     if (!RegisterClass( (LPWNDCLASS)pClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE) pClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND         hWnd;                /* Handle to the parent window    */

     WinInit (hInstance);

     hWnd = CreateWindow((LPSTR)"Window",
       (LPSTR)"ShowCaret",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,     /* x         */
                         CW_USEDEFAULT,     /* y         */
                         CW_USEDEFAULT,     /* width     */
                         CW_USEDEFAULT,     /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                        );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

 /*************************************************************************/

     CreateCaret (hWnd, NULL, 8, 12); /* Create a caret before showing */
     SetCaretPos (50,50);
     ShowCaret (hWnd);         /* ShowCaret doesn't return a value */

 /*************************************************************************/

     /* Message Box will make the parent window inactive */
     MessageBox (hWnd, (LPSTR)"The flashing black box is the caret",
     (LPSTR)"ShowCaret", MB_OK);


     return 0;
 }


 SIZEOFRE.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\RESOURCE\SIZEOFRE.C

 /*

 Name: Sizeofre.c

 Description        :
         FindResource is used first to locate and identify the resource
         item.  SizeofResource is used to determine how many bytes need
         to be read to obtain the resource item, and finally
         AccessResource() is used to get the handle and set the file
         pointer to the beginning of the selected resource.  AccessResource()
         opens the file (resource) as a result, so it must be explicitely
         closed.  In this case, "It works!" is displayed in a MessageBox()
         upon successful completion, "It failed" displays if unsuccessful.


 Additional Comments: Note that _lclose() must be used to close the file
 (resource).

 */

 #include <windows.h>
 #include "sizeofre.h"

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;
 int sprintf(PSTR, PSTR, int);
 int FAR PASCAL _lclose(int);
 int FAR PASCAL _lread(HANDLE, LPSTR, short);

 static char szBuffer[8];
 static int ErrorCheck;
 static char szResName [] = "HotStuff";

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "Resources" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "The Joy of Resources",     /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  static HANDLE hInstance, hResource;
  int hFile;

  PAINTSTRUCT ps;
  char szStuff[20], szSuccess[20];
  short sRes;
  HMENU hMenu;
  switch(iMessage)
  {
   case WM_CREATE:
   {
    hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
    hMenu = LoadMenu(hInstance, "ResMenu");
    SetMenu(hWnd, hMenu);
    DrawMenuBar(hWnd);
    break;
   }
   case WM_PAINT:
   {
    BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
    EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
    break;
   }
   case WM_COMMAND:
   {
    switch(wParam)
    {
     case IDM_EXECUTE:
     {
      /* FindResource is used first to locate and identify the resource
         item.  SizeofResource is used to determine how many bytes need
         to be read to obtain the resource item, and finally
         AccessResource() is used to get the handle and set the file
         pointer to the beginning of the selected resource.  AccessResource()
         opens the file (resource) as a result, so it must be explicitely
         closed.
      */
      hResource = FindResource(hInstance, "HotStuff", RT_RCDATA);
      sRes = SizeofResource(hInstance, hResource);
      hFile = AccessResource(hInstance, hResource);
      ErrorCheck = _lread(hFile, (LPSTR)szStuff, sRes);
      ErrorCheck = _lclose(hFile);
      if (hFile<1)
      {
       ErrorCheck = sprintf(szStuff, "It failed");
       ErrorCheck = sprintf(szSuccess, "Error");
      } else
      {
       ErrorCheck = sprintf(szSuccess, "Item read");
      }
      MessageBox(GetFocus(), szStuff, szSuccess, MB_OK);
     }
    }
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 SMAPFLAG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\FONTS\SMAPFLAG.C

 /*
  *  SetMapperFlags
  *  smapflag.c
  *
  *  This program demonstrates the use of the function SetMapperFlags.
  *  This function alters the algorithm that the font mapper uses when it
  *  maps logical fonts to physical fonts.  When the first bit in the first
  *  parameter is set to one, the mapper will only select fonts whose aspect
  *  ratios match those of the specified device.  If no fonts exit with a
  *  matching aspect ratio, GDI chooses an aspect ratio and select fonts
  *  with aspect ratios that match the one by GDI.
  *
  */

 #include "windows.h"

 static HANDLE hWnd;

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
   HDC hDC;
   PAINTSTRUCT ps;
   DWORD ptAspectRatio;
   DWORD ptMapperFlags;
   char szbuff[160];

   if ( !hPrevInstance )
      {
      WNDCLASS rClass;

      rClass.lpszClassName = ( LPSTR ) "smapflag";
      rClass.hInstance     = hInstance;
      rClass.lpfnWndProc   = DefWindowProc;
      rClass.hCursor       = LoadCursor ( NULL , IDC_ARROW );
      rClass.hIcon         = LoadIcon ( hInstance, IDI_APPLICATION );
      rClass.lpszMenuName  = ( LPSTR ) NULL;
      rClass.hbrBackground = GetStockObject ( WHITE_BRUSH );
      rClass.style         = CS_HREDRAW | CS_VREDRAW;
      rClass.cbClsExtra    = 0;
      rClass.cbWndExtra    = 0;

      RegisterClass ( ( LPWNDCLASS ) &rClass );
      }

   hWnd = CreateWindow ( ( LPSTR ) "smapflag", ( LPSTR ) "SetMapperFlags",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       CW_USEDEFAULT, CW_USEDEFAULT,
                       ( HWND ) NULL, ( HMENU ) NULL,
                       ( HANDLE ) hInstance, ( LPSTR ) NULL );

   ShowWindow ( hWnd , cmdShow );
   BeginPaint ( hWnd, ( LPPAINTSTRUCT ) &ps );
   hDC = ps.hdc;

   MessageBox (NULL, (LPSTR)"Setting font-mapper flag",
      (LPSTR)"SetMapperFlags", MB_OK);

   ptMapperFlags = SetMapperFlags( hDC, (long) 1 );

   ptAspectRatio = GetAspectRatioFilter ( hDC );

   sprintf ( szbuff, "%s%d%s%d\n%s%d%s%d\0", "Old aspect ratio is: x= ",
            HIWORD(ptMapperFlags), " y= ", LOWORD(ptMapperFlags),
            "New aspect ratio is: x= ", HIWORD(ptAspectRatio), " y= ",
            LOWORD(ptAspectRatio));

   MessageBox (NULL, (LPSTR) szbuff, (LPSTR)"SetMapperFlags", MB_OK);

   return 0;
 }


 SMETAFB.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\METAFILE\SMETAFB.C

 /*
  * This application demonstrates the SetMetaFile() Windows function.
  * The result is demonstrated on the screen.
  *
  */
 #include "windows.h"

 static HANDLE hInst;
 HANDLE hMF;
 HANDLE hMem;
 HANDLE hMetaDC;
 HANDLE hSetMF;

 long FAR PASCAL SetMetaWndProc(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     if (!hPrevInstance) {
        PWNDCLASS   pSetMetaClass;

        pSetMetaClass = (PWNDCLASS)LocalAlloc(LPTR, sizeof(WNDCLASS));

        pSetMetaClass->hCursor        = LoadCursor(NULL, IDC_ARROW);
        pSetMetaClass->hIcon          = NULL;
        pSetMetaClass->lpszMenuName   = (LPSTR)NULL;
        pSetMetaClass->lpszClassName  = (LPSTR)"SetMetaFileBits";
        pSetMetaClass->hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
        pSetMetaClass->hInstance      = hInstance;
        pSetMetaClass->style          = CS_HREDRAW | CS_VREDRAW;
        pSetMetaClass->lpfnWndProc    = SetMetaWndProc;

        if (!RegisterClass((LPWNDCLASS)pSetMetaClass))
            return FALSE;

        LocalFree((HANDLE)pSetMetaClass);
        }

     hWnd = CreateWindow((LPSTR)"SetMetaFileBits",
                         (LPSTR)"SetMetaFileBits() Demo",
                         WS_TILEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,
                         (HMENU)NULL,
                         (HANDLE)hInstance,
                         (LPSTR)NULL
                         );

     hInst = hInstance;

     hMetaDC = CreateMetaFile(NULL);
     if (hMetaDC == NULL)
        MessageBox(GetFocus(),
                   (LPSTR)"Error in Creating Memory Metafile",
                   (LPSTR)"CreateMetaFile() Error!",
                   MB_OK | MB_ICONEXCLAMATION);
     else {
        Rectangle(hMetaDC, 10, 10, 200, 200);
        Rectangle(hMetaDC, 201, 10, 401, 200);
        LineTo(hMetaDC, 100, 250);
        Ellipse(hMetaDC, 0, 0, 100, 100);
        hMF = CloseMetaFile(hMetaDC);
        if (hMF == NULL)
           MessageBox(GetFocus(),
                      (LPSTR)"Error Closing Meta File.",
                      (LPSTR)"CloseMetaFile() Error!",
                      MB_OK | MB_ICONEXCLAMATION);
        else {
           hMem = GetMetaFileBits(hMF);
           if (hMem == NULL)
              MessageBox (GetFocus(),
                          (LPSTR)"Error in Obtaining Metafile Bit Handle",
                          (LPSTR)"GetMetaFileBits() Error!!!",
                          MB_OK | MB_ICONEXCLAMATION);
           else {
              hSetMF = SetMetaFileBits(hMem);
              if (hSetMF == NULL)
                 MessageBox(GetFocus(),
                            (LPSTR)"Error in Setting Meta File Bits!",
                            (LPSTR)"SetMetaFileBits() Error!!!",
                            MB_OK | MB_ICONEXCLAMATION);
              }
           }
        }

     ShowWindow(hWnd, cmdShow);
     UpdateWindow(hWnd);

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 long FAR PASCAL SetMetaWndProc(hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
    PAINTSTRUCT ps;
    HDC         hDC;

    switch (iMessage) {
       case WM_PAINT:
          hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
          PlayMetaFile(hDC, hSetMF);
          EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
          break;

       default:
          return DefWindowProc(hWnd, iMessage, wParam, lParam);
       }
    return(0L);
 }



 SOUNDX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SOUND\SOUNDX.C

 /***********************************************************************
  *** Functions demonstrated: (all of them...)
  ***      CloseSound, OpenSound,
  ***      StartSound, StopSound,
  ***      CountVoiceNotes, SetVoiceNote,
  ***      SetVoiceSound, SetSoundNoise,
  ***      SetVoiceQueueSize, SetVoiceAccent,
  ***      SetVoiceEnvelope, SetVoiceThreshold,
  ***      GetThresholdEvent, GetThresholdStatus,
  ***      SyncAllVoices, WaitSoundState.
  ***
  *** Note that the files are not named SOUND.  This is because
  *** Windows has an internal driver named sound and will not accept
  *** sound as an application name.
  ************************************************************************/

 #include <windows.h>
 #include <stdio.h>
 #include "soundx.h"

 long FAR PASCAL SoundWndProc (HWND, unsigned, WORD, LONG);

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;

     if (!hPrevInstance)
   {
   wndclass.style    = CS_HREDRAW | CS_VREDRAW;
   wndclass.lpfnWndProc  = SoundWndProc;
   wndclass.cbClsExtra  = 0;
   wndclass.cbWndExtra  = 0;
   wndclass.hInstance  = hInstance;
   wndclass.hIcon    = LoadIcon(NULL, IDI_ASTERISK);
   wndclass.hCursor  = LoadCursor(NULL,  IDC_ARROW);
   wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wndclass.lpszMenuName  = "SoundMenu";
   wndclass.lpszClassName  = "Sound";

   if (!RegisterClass(&wndclass) )
       return FALSE;
   }

     hWnd = CreateWindow("Sound", "Sound Window",
     WS_MINIMIZEBOX | WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU,
     270, 130, 40, 54, NULL, NULL, hInstance, NULL);

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

     while (GetMessage(&msg, NULL, 0,0 ))
   {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
   }

     return msg.wParam;
     }

 long FAR PASCAL SoundWndProc (hWnd, iMessage, wParam, lParam)
     HWND    hWnd;
     unsigned    iMessage;
     WORD    wParam;
     LONG    lParam;
     {
     char   szJunk[40];    /* Buffer fo MessageBoxes    */
     unsigned int nIndex;    /* Generic index counter    */
     static int   nNoise=0,    /* Noise parameter      */
      nCount=0;    /* Number returned from GetVoiceNotes */
     static BOOL  bThresh=FALSE,   /* SetVoiceThreshold flag    */
      bEnv=FALSE;    /* SetVoiceEnvelope flag    */

     /* Notes from The Appassionata          */
     static int   nNotes[60]={45,42,38,45,38,47,43,38,45,42,38,45,
            38,45,40,47,45,40,38,40,37,45,40,37,
            45,42,38,45,42,50,45,42,50,45,42,50,
            43,50,47,43,50,45,42,50,42,50,44,50,
            40,49,45,40,49,45,40,49,50,45,40,33};

     switch (iMessage)
   {
   case WM_DESTROY:
       PostQuitMessage(0);
       /* fall through */

   /* Release resources if focus is lost or window is iconized  */
   /* or ended.  Remove these and a constant sound will continue  */
   /* for a time even if the window is no longer around.  The bad  */
   /* part is that sound resources are not released and that can  */
   /* screw up DOS as well as Windows.        */
   case WM_KILLFOCUS:
   case WM_SETVISIBLE:
       CloseSound();
       StopSound();
       break;

   /* Open sound resources if window is opened or obtains the focus*/
   case WM_SETFOCUS:
       OpenSound();
       break;

   case WM_COMMAND:
       /* Set number of notes in queue.  Windows only has multiple */
       /* voice capability if the computer has sound hardware.  */
       SetVoiceQueueSize(1, 600);

       switch (wParam)
     {
     case ID_NOTES:
         /* Set temp, volume, and style of notes.  For the  */
         /* most part, the tempo parameter (2nd) is the only */
         /* effective value on machines without additional  */
         /* sound hardware (volume is ineffective).    */
         SetVoiceAccent(1, 220, 20, S_NORMAL, 0);

         /* Set the number of notes in threshold to 30.  This*/
         /* causes the threshold flag to be set when the  */
         /* number of remaining notes falls below 30.  */
         if (bThresh)
       SetVoiceThreshold(1, 30);

         /* Set an envelope          */
         SetVoiceEnvelope(1, bEnv, 3);

         /* Set notes in queue.  Note 0 is a rest, note 1 is */
         /* two octaves below middle C.  Concert A (440Hz) is*/
         /* 34.  To prove this, do SetVoiceNote(1,34,1,0)  */
         /* and SetVoiceSound(1,440L*65536L, 300).  The tones*/
         /* are equivalent.          */
         for (nIndex=84; nIndex > 0; nIndex -=1 )
       SetVoiceNote(1, nIndex, 250, 0);

         /* Play the sound          */
         StartSound();

         /* Retain the count of notes      */
         nCount=CountVoiceNotes(1);
         break;

     case ID_SOUND:
         /* Set sounds in queue.  Second parameter to  */
         /* SetVoiceSound is a LONG, not an int as stated in */
         /* the documentation. Also, the documentation states*/
         /* that the high-order word of the second parameter */
         /* is the frequency in Kilohertz.  However, it is  */
         /* actually in Hertz.  Otherwise, this routine would*/
         /* produce very minimal audible sound.    */

         for (nIndex=750; nIndex >=1; nIndex -=3)
       SetVoiceSound(1, (unsigned long)(nIndex*65536L), 3);

         StartSound();
         nCount=0;

         /* Wait until all sounds have been played    */
         WaitSoundState(S_QUEUEEMPTY);
         break;

     case ID_NOISE:
         /* Start noise. Must StartSound after SetSoundNoise.*/
         /* Full use of this function requires other sound  */
         /* drivers not available on standard machines.  */
         StopSound();
         SetSoundNoise(nNoise++, 100);
         StartSound();
         nCount=0;
         for (nIndex=0; nIndex < 65535; nIndex++); /* pause  */
         StopSound();
         nNoise &=7;
         break;

     case LUDWIG:
         /* Play beginning of second movement to the Andante */
         /* in Beethoven's Appassionata.                     */
         StopSound();
         SetVoiceAccent(1, 70, 120, S_LEGATO, 0);
         SetVoiceEnvelope(1, bEnv, 3);
         if (bThresh)
       SetVoiceThreshold(1, 30);

         /* Set notes from the data array.      */
         for (nIndex=0; nIndex<60; nIndex++)
       SetVoiceNote(1, nNotes[nIndex], 16, 0);

         SetVoiceNote(1,50,4,0); /* Longer final note.  */

         /* Start sound.  Continues playing until it done,  */
         /* the window is detroyed, loses the input focus,  */
         /* or iconized.  WaitSoundState can be used to wait */
         /* until the sound is finished.      */
         StartSound();
         nCount=CountVoiceNotes(1);
         break;

     case ID_COUNT:
         /* Show the current value of nCount. GetVoiceNotes  */
         /* only counts notes, not sounds, envelopes, etc.  */
         sprintf(szJunk, "Notes=%d", nCount);
         MessageBox(hWnd, szJunk, "CountVoiceNotes", MB_OK);
         break;

     case ID_SYNC:
         /* SyncAllVoices is really only effective with  */
         /* multivoice support. On standard machines this  */
         /* function is not successful.      */
         if (SyncAllVoices())
       MessageBox(hWnd, "SyncAllVoices successful.",
            "SyncAllVoices", MB_OK);
         else
       MessageBox(hWnd, "SyncAllVoices unsuccessful.",
            "SyncAllVoices", MB_OK);
         break;

     case ID_ENV:
         bEnv=!bEnv;
         if(bEnv)
       MessageBox(hWnd, "Envelope ON",
            "SetVoiceThreshold", MB_OK);
         else
       MessageBox(hWnd, "Envelope OFF",
            "SetVoiceThreshold", MB_OK);

         break;

     case ID_EVENT:
         /* Returns a pointer to an int      */
         sprintf(szJunk, "returns: %d", *(GetThresholdEvent()));
         MessageBox(hWnd, szJunk, "GetThresholdEvent", MB_OK);
         break;

     case ID_STATUS:
         /* GetThresholdStatus retrieves an int.  Each bit  */
         /* has the status for each voice.      */
         /* If a bit is set, the the threshold level for  */
         /* that voice has been reached.      */
         if (GetThresholdStatus())
       MessageBox(hWnd, "Threshold reached.",
            "GetThresholdStatus", MB_OK);
         else
       MessageBox(hWnd, "Threshold not reached.",
            "GetThresholdStatus", MB_OK);

         break;

     case ID_SETVT:
         /* Here a flag is toggled for NOTES and LUDWIG.  */
         bThresh=!bThresh;
         if(bThresh)
       MessageBox(hWnd, "Threshold ON",
            "SetVoiceThreshold", MB_OK);
         else
       MessageBox(hWnd, "Threshold OFF",
            "SetVoiceThreshold", MB_OK);
         break;
     }
   default:
       return (DefWindowProc(hWnd, iMessage, wParam, lParam));
   }
     return 0L;
     }


 STJUST.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\STJUST.C

 /*
 Function(s) demonstrated in this program: SetTextJustification
 Compiler version: 5.1
 Description: This program removes leading spaces from the given string,
              counts the number of spaces left, removes and subtracts the
              trailing spaces, and then justifies the remaining string to
              zero and eighty.
 */

 #include <windows.h>

 long FAR PASCAL WndProc ( HWND, unsigned, WORD, LONG );
 extern LPSTR FAR PASCAL lstrcpy ( LPSTR, LPSTR );
 extern int   FAR PASCAL lstrlen ( LPSTR );
 void Justify ( HDC );

 static char szAppName [] = "STJUST" ;
 static char szFuncName [] = "SetTextJustification" ;

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance;
 HANDLE      hPrevInstance;
 LPSTR       lpszCmdLine;
 int         nCmdShow;
 {
      HWND        hWnd;
      WNDCLASS    wndclass;
      MSG         msg;

      if (!hPrevInstance) {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     szFuncName,                 /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

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

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
 }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd;
 unsigned iMessage;
 WORD     wParam;
 LONG     lParam;
 {
    HDC         hDC;
    PAINTSTRUCT ps;

    switch(iMessage)
       {
       case WM_PAINT:
          hDC = BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
          Justify ( hDC );
          EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
          break;
       case WM_DESTROY:
          PostQuitMessage(0);
          break;
       default:
          return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
       }
    return (0L);
 }

 void Justify ( hDC )
 HDC   hDC;
 {
    TEXTMETRIC  tmText;
    DWORD       dwExtent;
    char        szJustifyString [80];
    int         nBreakCount;
    int         nElement;
    int         nIndex;

    lstrcpy ( (LPSTR)szJustifyString,
       (LPSTR)"    This string is justified between 0 and 80.   \0" );

    GetTextMetrics ( hDC, (LPTEXTMETRIC)&tmText );

    nBreakCount = 0;
    nElement = 0;

                                                  /* Removing leading spaces *
    while ( szJustifyString [ nElement ]  == ' ' &&
       szJustifyString [ nElement ] != '\0' )
       {
       for ( nIndex = 0; nIndex < lstrlen ( (LPSTR)szJustifyString );
        nIndex++ )
          szJustifyString [ nIndex ] = szJustifyString [ nIndex + 1 ];
       }

                                                /* Counting remaining spaces *
    do
       {
       while ( szJustifyString [ nElement ] != '\0' &&
          szJustifyString [ nElement++ ] != ' ');
       if ( szJustifyString [ nElement ] == '\0' )
          break;

       nBreakCount++;
                                           /* Clearing error out of dwExtent *
       SetTextJustification ( hDC, 0, 0 );
       dwExtent = GetTextExtent ( hDC, (LPSTR)szJustifyString,
          lstrlen ( (LPSTR)szJustifyString ) - 1 );
       }
    while ( LOWORD ( dwExtent ) < tmText.tmAveCharWidth * 80 );

                                                 /* Removing trailing spaces *
    nBreakCount--;
    nElement = lstrlen ( (LPSTR)szJustifyString );
    while ( szJustifyString [ nElement ]  == ' ' && nElement != 0 )
       {
       nElement--;
       nBreakCount--;
       }
                                           /* Clearing error out of dwExtent *
    SetTextJustification ( hDC, 0, 0 );
                                         /* Justifing string szJustifyString *
    dwExtent = GetTextExtent ( hDC, (LPSTR)szJustifyString,
       lstrlen ( (LPSTR)szJustifyString ) - 1 );
    SetTextJustification ( hDC, tmText.tmAveCharWidth * 80 -
       (int)LOWORD ( dwExtent ), nBreakCount );

    TextOut ( hDC, 0 , 0 + (int)HIWORD ( dwExtent ), (LPSTR)szJustifyString,
       lstrlen ( (LPSTR)szJustifyString ) );
 }


 STMENU.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MENU\STMENU.C

 /*
  *  Program Name:    stmenu.c
  *
  *  Description:
  *   The program below creates a menu and sets it in the window.
  *
  */

 #include "windows.h"

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 /***********************************************************************/

 void CALL_SetMenu(hWnd, hDC)
 HWND hWnd;
 HDC hDC;
 {
   HMENU         hCurrentWindowMenu;
   unsigned      wIDItem;
   BOOL          bSet;

   hCurrentWindowMenu = CreateMenu();
   ChangeMenu (hCurrentWindowMenu, NULL, (LPSTR) "Heading", wIDItem,
               MF_APPEND | MF_BYCOMMAND | MF_STRING);

   bSet = SetMenu(hWnd, hCurrentWindowMenu);  /* menu set and displayed */

   if (bSet == FALSE)
     MessageBox(hWnd, (LPSTR)"SetMenu failed", (LPSTR)"ERROR", MB_ICONHAND);

   return;
 }

 /**************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = WndProc;
     wcClass.cbClsExtra     =0;
     wcClass.cbWndExtra     =0;
     wcClass.hInstance      = hInstance;
     wcClass.hIcon          = LoadIcon( hInstance,NULL );
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"SetMenu";

     if (!RegisterClass( (LPWNDCLASS)&wcClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;

     if (!hPrevInstance)
         {
         /* Call initialization procedure if this is the first instance */
         if (!WinInit( hInstance ))
             return FALSE;
         }

     hWnd = CreateWindow((LPSTR)"SetMenu",
                         (LPSTR)"SetMenu()",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0))
         {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /* Procedures which make up the window class. */
 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         CALL_SetMenu(hWnd, ps.hdc);
         ValidateRect(hWnd, (LPRECT) NULL);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 STSYSCOL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\STSYSCOL.C

 /*
  * This program demonstrates the use of SetSysColor(). In this example,
  * the background desktop color of the current windows session is changed
  * to black. This change is not permanent. If the background is already
  * set to black, no change will be visible.
  */

 #include <windows.h>

 #define MAXCOLORS         13

 DWORD lpColorValues[MAXCOLORS];
 int lpSysColor[MAXCOLORS] = { COLOR_SCROLLBAR,
                               COLOR_BACKGROUND,
                               COLOR_ACTIVECAPTION,
                               COLOR_INACTIVECAPTION,
                               COLOR_MENU,
                               COLOR_WINDOW,
                               COLOR_WINDOWFRAME,
                               COLOR_MENUTEXT,
                               COLOR_WINDOWTEXT,
                               COLOR_CAPTIONTEXT,
                               COLOR_ACTIVEBORDER,
                               COLOR_INACTIVEBORDER,
                               COLOR_APPWORKSPACE };

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
    int         i;

    MessageBox(GetFocus(), (LPSTR)"Setting Background Color to Black.",
               (LPSTR)"SetSysColors()", MB_OK);

    for (i = 0; i < MAXCOLORS; i++)
       lpColorValues[i] = GetSysColor(lpSysColor[i]);

    lpColorValues[COLOR_BACKGROUND] = RGB(0, 0, 0);
    SetSysColors(MAXCOLORS, (int far *)lpSysColor, (long far *)lpColorValues);

    MessageBox(GetFocus(), (LPSTR)"Background Set For Current Session Only.",
               (LPSTR)"SetSysColors()", MB_OK);

    return(0);

 }


 STXTCHX.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\STXTCHX.C

 /*
  * SetTextCharacterExtra
  * gtxtchx.c
  *
  * This program registers a window and creates it on the screen.  The
  *  program then creates the window, shows the window, and then updates
  *  the window.  If the user couble clicks the right mouse button, the
  *  SetTextCharacterExtra function is executed.  The intercharacter
  *  spacing is returned and displayed in a message box.
  *
  */

 #include "windows.h"

 /* Global Variables */
 static HANDLE hInst;
 static HWND hWnd;

 /* FORWARD REFERENCES */
 long FAR PASCAL WindowProc (HWND, unsigned, WORD, LONG);

 /* WINMAIN */
 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
   MSG msg;

   if (!hPrevInstance)  {

      WNDCLASS rClass;

      rClass.lpszClassName = (LPSTR)"stxtchx";
      rClass.hInstance    = hInstance;
      rClass.lpfnWndProc   = WindowProc;
      rClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
      rClass.hIcon        = LoadIcon(hInstance, IDI_APPLICATION);
      rClass.lpszMenuName  = (LPSTR)NULL;
      rClass.hbrBackground = GetStockObject(WHITE_BRUSH);
      rClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
      rClass.cbClsExtra    = 0;       /* Add double click capabilities. */
      rClass.cbWndExtra    = 0;

      RegisterClass((LPWNDCLASS)&rClass);

      }
    else
       ;

    hInst = hInstance;

    hWnd = CreateWindow((LPSTR) "stxtchx",
            (LPSTR) "SetTextCharacterExtra", /* Create a window.         */
            WS_OVERLAPPEDWINDOW,             /* Make it overlapped.      */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            CW_USEDEFAULT,                   /* Use default coordinates. */
            (HWND)NULL,
            (HMENU)NULL,
            (HANDLE)hInstance,
            (LPSTR)NULL
          );

    ShowWindow(hWnd, cmdShow);

    UpdateWindow(hWnd);

    while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    exit(msg.wParam);

 } /* WinMain */

 /* WINDOWPROC */

 long FAR PASCAL WindowProc(hWnd, identifier, wParam, lParam)
 HWND  hWnd;
 unsigned identifier;
 WORD   wParam;
 LONG   lParam;

 {

    switch (identifier) {

      case WM_PAINT: {

          PAINTSTRUCT ps;
         RECT      rRect;
        HDC      hDC;

        hDC=BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        SetMapMode(hDC, MM_ANISOTROPIC);
        SetWindowOrg(hDC, 0, 0);
        SetWindowExt(hDC, 110, 110);
        GetClientRect(hWnd, (LPRECT)&rRect);
        SetViewportOrg(hDC, 0, 0);
        SetViewportExt(hDC, rRect.right, rRect.bottom);
        DrawText(hDC,
                 (LPSTR)"Double Click Right Mouse Button To Set Intercharacter
                 62, (LPRECT)&rRect, DT_SINGLELINE);  /* Place text to    */
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);          /* prompt for test. */

     }
       break;

      case WM_RBUTTONDBLCLK:                    /* If the user double    */
        {                                       /* clicks on the right   */
        char szbuf[80];   /* Output buffer       | mouse button, then    */
        short sIntSpacing; /* Interchar spacing. | variables and call    */
        short sOldIntSpacing; /* Old spacing.  */
        HDC hDC; /* Handle to display Context. */

        hDC = GetDC(hWnd);                      /* (after getting DC)    */
        sIntSpacing = GetTextCharacterExtra(hDC); /* GetTextCharacterExtra */
                                                /* (with the display     */
                                                /* context of the top    */
                                                /* level window.         */
       sprintf(szbuf,                          /* Capture the interchar */
           "%s%i%s\0",                          /* spacing information   */
           "Current Intercharacter Spacing = ", /* in a zero terminated  */
          (int)sIntSpacing, ".");              /* buffer.               */
       MessageBox(hWnd,                        /* Output the buffer in  */
                   (LPSTR)szbuf,                /* a message box format  */
                   (LPSTR)"SetTextCharacterExtra", /* so that the user   */
                  MB_OK);                      /* can have a readable   */
                                                /* and useful format.    */

        sOldIntSpacing = SetTextCharacterExtra(hDC, 10);
                                                /* Set the new spacing   */
                                                /* to 10.                */

        if (sIntSpacing != sOldIntSpacing)
           {                                    /* Issue error if fails. */
           MessageBox(hWnd, (LPSTR)"SetTextCharacterExtra Failed!!!",
                      (LPSTR)"ERROR!!!",
                      MB_OK | MB_ICONEXCLAMATION);
           break;
           };
                                                /* Output confirmation.  */
        MessageBox(hWnd, (LPSTR)"Set the Intercharacter Spacing to 10.",
                   (LPSTR)"Setting = 10",
                   MB_OK);
                                                /* Get new spacing.      */
        sIntSpacing = GetTextCharacterExtra(hDC);

        sprintf(szbuf,
           "%s%i%s\0",
           "New Intercharacter Spacing = ",
          (int)sIntSpacing, ".");
       MessageBox(hWnd,                        /* Show that Set worked. */
                   (LPSTR)szbuf,
                   (LPSTR)"SetTextCharacterExtra",
                  MB_OK);
        }
        break;

      case WM_CLOSE: {

         DestroyWindow(hWnd);
        }
      break;

     case WM_DESTROY:
       PostQuitMessage(0);
       break;

     default:
       return(DefWindowProc(hWnd, identifier, wParam, lParam));
       break;

    }

    return(0L);

 }


 SWAPAREA.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\SWAPAREA.C

 /*
 Name               : swaparea.c
 Date               : 07-05-88
 Function(s)
 demonstrated in
 this program       : SetSwapAreaSize(), GlobalCompact().
 Windows version    : 2.03
 Compiler version   : 5.1
 Description        : SetSwapAreaSize() increases the amount of memory that
                      an application uses for its code segment.  The memory
                      used for this application may not be allocated for
                      data.
 */

 #include <windows.h>
 #include "swaparea.h"

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;
 int sprintf(PSTR, PSTR, int);

 static int ErrorCheck;
 static char szResName [] = "ResMenu";

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "swaparea" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "The Joy of Swapping",       /* window caption          *
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  static HANDLE hInstance;
  DWORD TotalFree;
  PAINTSTRUCT ps;
  char szBuf[50];
  HMENU hMenu;
  switch(iMessage)
  {
   case WM_CREATE:
   {
    hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
    hMenu = LoadMenu(hInstance, "ResMenu");
    SetMenu(hWnd, hMenu);
    DrawMenuBar(hWnd);
    break;
   }
   case WM_PAINT:
   {
    BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
    EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
    break;
   }
   case WM_COMMAND:
   {
    switch(wParam)
    {
     case IDM_EXECUTE:
     {
      /* Compact the memory to maximize the amount of free space, then
         allocate 1/2 the total available for this applications code
         segment.  This can only be done once.
      */
      TotalFree = (GlobalCompact(NULL)/(16*1024))/2;
      ErrorCheck = SetSwapAreaSize((WORD)TotalFree);
      sprintf(szBuf, "%i paragraphs that have been obtained for code segment u
      MessageBox(GetFocus(), szBuf, "There are", MB_OK);
     }
    }
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 SWAPBTN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MOUSE\SWAPBTN.C

 /*
  *   SwapMouseButton
  *   swapbtn
  *
  *   This program demonstrates the use of the function SwapMouseButton.
  *   First, a message box opens and only the left mouse button will close
  *   it.  The functionality of the mouse buttons are switched using
  *   SetMouseButton and another message box is displayed.  This time only
  *   the right mouse button will close the message box.  The mouse buttons
  *   are finally reset before closing.
  *
  */

 #include "windows.h"

 /* Forward References */

 BOOL FAR PASCAL SampleInit(HANDLE);

 long FAR PASCAL SampleWndProc(HWND, unsigned, WORD, LONG);

 /***************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;

     SampleInit( hInstance );
     hWnd = CreateWindow((LPSTR)"SwapMouseButton",
       (LPSTR)"SwapMouseButton",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );
 /************************************************************************/
 /* Beginning of SwapMouseButton section */

 MessageBox (hWnd, (LPSTR)"The functionality of the mouse buttons will be swit
             (LPSTR)"Done", MB_OK);

 SwapMouseButton(FALSE);                  /* Initialize the mouse buttons */

 MessageBox (hWnd, (LPSTR)"Only the left mouse button will close this message
             (LPSTR)"Done", MB_OK);

 SwapMouseButton(TRUE);                   /* Switch the mouse buttons */

 MessageBox (hWnd, (LPSTR)"Only the right mouse button will close this message
             (LPSTR)"Done", MB_OK);

 SwapMouseButton(FALSE);                  /* Reset the mouse buttons */

 MessageBox (hWnd, (LPSTR)"The mouse buttons are now reset.",
             (LPSTR)"Done", MB_OK);

 /************************************************************************/

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }

 /***************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL FAR PASCAL SampleInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pSampleClass;

     pSampleClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pSampleClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pSampleClass->hIcon          = LoadIcon( hInstance,NULL);
     pSampleClass->lpszMenuName   = (LPSTR)NULL;
     pSampleClass->lpszClassName  = (LPSTR)"SwapMouseButton";
     pSampleClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pSampleClass->hInstance      = hInstance;
     pSampleClass->style          = CS_HREDRAW | CS_VREDRAW;
     pSampleClass->lpfnWndProc    = SampleWndProc;

     if (!RegisterClass( (LPWNDCLASS)pSampleClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pSampleClass );
     return TRUE;        /* Initialization succeeded */
 }


 /**************************************************************************/
 /* Every message for this window will be delevered right here.         */

 long FAR PASCAL SampleWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message)
     {
     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 TEXTALGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\TEXTALGN.C

 /*
  * This application demonstrates the GetTextAlign() and SetTextAlign()
  * Windows functions. This program is a subset of the SHOWFONT learning
  * guide application. See that program for a more comprehensive example.
  *
  * In this application, a vertical and/or horizontal alignment is
  * selected via the "Options..." menu (or the defaults are used),
  * and the left mouse button is clicked in the client area of this
  * demo application.
  *
  */

 #include "windows.h"
 #include <string.h>
 #include "textalgn.h"

 /* Function Prototypes */

 void SetMyDC(HDC);
 short StringOut(HDC, short, short, PSTR, HFONT);
 void ShowString(HWND);
 long FAR PASCAL TextAlgnWndProc(HWND, unsigned, WORD, LONG);

 HANDLE  hInst;
 HFONT   hSFont, hFont;
 char    line[4][64];
 LOGFONT LogFont;
 POINT   ptCurrent = {0, 0};
 short   nBkMode = OPAQUE;
 DWORD   rgbBkColor = RGB(255, 255, 255);
 DWORD   rgbTextColor = RGB(0, 0, 0);
 short   nAlignLCR = TA_LEFT;
 short   nAlignTBB = TA_TOP;
 WORD    wPrevVAlign = IDM_ALIGNBASE;
 WORD    wPrevHAlign = IDM_ALIGNLEFT;
 char    AppName[] = "Get/SetTextAlign() Demo";
 char    WindowTitle[80];


 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;
 HANDLE hPrevInstance;
 LPSTR  lpCmdLine;
 int    nCmdShow;
 {
     HWND hWnd;
     PWNDCLASS pWndClass;
     MSG msg;

     if (!hPrevInstance) {
        pWndClass->hCursor       = LoadCursor(NULL, IDC_ARROW);
        pWndClass->hIcon         = NULL;
        pWndClass->lpszMenuName  = (LPSTR) "TextAlgn";
        pWndClass->lpszClassName = (LPSTR) "TextAlgn";
        pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
        pWndClass->hInstance     = hInstance;
        pWndClass->style         = NULL;
        pWndClass->lpfnWndProc   = TextAlgnWndProc;
        RegisterClass((LPWNDCLASS) pWndClass);
        }

     hInst = hInstance;

     hWnd = CreateWindow((LPSTR)"TextAlgn",
                         (LPSTR)"TextAlgn",
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         NULL,
                         NULL,
                         hInstance,
                         NULL);

     if (!hWnd)
         return (FALSE);

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

     while (GetMessage(&msg, NULL, NULL, NULL)) {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
     }
     return (msg.wParam);
 }


 /****************************************************************************

     FUNCTION: SetMyDC(HDC)

     PURPOSE: Initializes the DC

 ****************************************************************************/

 void SetMyDC(hDC)
 HDC hDC;
 {
     SetBkMode(hDC, nBkMode);
     SetBkColor(hDC, rgbBkColor);
     SetTextColor(hDC, rgbTextColor);
     SetTextAlign(hDC, nAlignLCR | nAlignTBB);
 }

 /****************************************************************************

     FUNCTION: StringOut(HDC, short, short, PSTR, HFONT)

     PURPOSE: Outputs a string to application's window

 ****************************************************************************/

 short StringOut(hDC, X, Y, pString, hFont)
 HDC   hDC;
 short X;
 short Y;
 PSTR  pString;
 HFONT hFont;
 {
     HFONT hOldFont;
     DWORD dwExtent;

     hOldFont = SelectObject(hDC, hFont);
     if (hOldFont != NULL) {
         dwExtent = GetTextExtent(hDC, pString, strlen(pString));
         TextOut(hDC, X, Y, pString, strlen(pString));
         SelectObject(hDC, hOldFont);
     }
     return (LOWORD(dwExtent));
 }

 /****************************************************************************

     FUNCTION: ShowString(HWND)

     PURPOSE: Show string in current font

 ****************************************************************************/

 void ShowString(hWnd)
 HWND hWnd;
 {
     HFONT hItalicFont;
     HFONT hBoldFont;
     HFONT hUnderlineFont;
     HFONT hStrikeOutFont;
     HDC   hDC;
     short X, tmpX;
     short Y;
     short nAlign;

     GetObject(hFont, sizeof(LOGFONT), (LPSTR) &LogFont);
     LogFont.lfItalic    = TRUE;
     hItalicFont         = CreateFontIndirect(&LogFont);
     LogFont.lfItalic    = FALSE;
     LogFont.lfUnderline = TRUE;
     hUnderlineFont      = CreateFontIndirect(&LogFont);
     LogFont.lfUnderline = FALSE;
     LogFont.lfStrikeOut = TRUE;
     hStrikeOutFont      = CreateFontIndirect(&LogFont);
     LogFont.lfStrikeOut = FALSE;
     LogFont.lfWeight    = FW_BOLD;
     hBoldFont           = CreateFontIndirect(&LogFont);

     hDC = GetDC(hWnd);
     SetMyDC(hDC);
     X = ptCurrent.x;
     Y = ptCurrent.y;
     nAlign = nAlignLCR | nAlignTBB;                 /* GetTextAlign(hDC); */
     if ((nAlign & TA_CENTER) == TA_CENTER) {
         tmpX = X;
         nAlignLCR = TA_LEFT;
         SetTextAlign(hDC, nAlignLCR | nAlignTBB);
         X += StringOut(hDC, X, Y, ", and ", hFont);
         X += StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X += StringOut(hDC, X, Y, " in a single line.", hFont);
         X = tmpX;
         nAlignLCR = TA_RIGHT;
         SetTextAlign(hDC, nAlignLCR | nAlignTBB);
         X -= StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "italic", hItalicFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "bold", hBoldFont);
         X -= StringOut(hDC, X, Y, "You can use ", hFont);
         nAlignLCR = TA_CENTER;
     }
     else if ((nAlign & TA_CENTER) == TA_RIGHT) {
         X -= StringOut(hDC, X, Y, " in a single line.", hFont);
         X -= StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X -= StringOut(hDC, X, Y, ", and ", hFont);
         X -= StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "italic", hItalicFont);
         X -= StringOut(hDC, X, Y, ", ", hFont);
         X -= StringOut(hDC, X, Y, "bold", hBoldFont);
         X -= StringOut(hDC, X, Y, "You can use ", hFont);
     }
     else  {
         X += StringOut(hDC, X, Y, "You can use ", hFont);
         X += StringOut(hDC, X, Y, "bold", hBoldFont);
         X += StringOut(hDC, X, Y, ", ", hFont);
         X += StringOut(hDC, X, Y, "italic", hItalicFont);
         X += StringOut(hDC, X, Y, ", ", hFont);
         X += StringOut(hDC, X, Y, "underline", hUnderlineFont);
         X += StringOut(hDC, X, Y, ", and ", hFont);
         X += StringOut(hDC, X, Y, "strikeout", hStrikeOutFont);
         X += StringOut(hDC, X, Y, " in a single line.", hFont);
     }
     ReleaseDC(hWnd, hDC);

     DeleteObject(hItalicFont);
     DeleteObject(hUnderlineFont);
     DeleteObject(hStrikeOutFont);
     DeleteObject(hBoldFont);
 }

 /****************************************************************************

     FUNCTION: TextAlgnWndProc(HWND, unsigned, WORD, LONG)

     PURPOSE: Processes messages

 ****************************************************************************/

 long FAR PASCAL TextAlgnWndProc(hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
 {
     HDC         hDC;
     PAINTSTRUCT ps;
     int         i;

     switch(message) {
         case WM_CREATE:
             hSFont = GetStockObject(SYSTEM_FONT);
             hFont  = hSFont;
             GetObject(hFont, sizeof(LOGFONT), (LPSTR) &LogFont);

             for (i=0; i<64; i++) {
                 line[0][i] = (char)i;
                 line[1][i] = (char)i+64;
                 line[2][i] = (char)i+128;
                 line[3][i] = (char)i+192;
             }
             break;

         case WM_PAINT:
             hDC = BeginPaint(hWnd, &ps);
             SetMyDC(hDC);
             EndPaint(hWnd, &ps);
             break;

         case WM_COMMAND:
             switch (wParam) {
                 case IDM_CLEAR:
                     InvalidateRect(hWnd, (LPRECT)NULL, TRUE);
                     break;

                 case IDM_ALIGNLEFT:
                     nAlignLCR = TA_LEFT;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNCENTER:
                     nAlignLCR = TA_CENTER;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNRIGHT:
                     nAlignLCR = TA_RIGHT;
                     CheckMenuItem(GetMenu(hWnd), wPrevHAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevHAlign = wParam;
                     break;

                 case IDM_ALIGNTOP:
                     nAlignTBB = TA_TOP;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;

                 case IDM_ALIGNBASE:
                     nAlignTBB = TA_BASELINE;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;

                 case IDM_ALIGNBOTTOM:
                     nAlignTBB = TA_BOTTOM;
                     CheckMenuItem(GetMenu(hWnd), wPrevVAlign, MF_UNCHECKED);
                     CheckMenuItem(GetMenu(hWnd), wParam, MF_CHECKED);
                     wPrevVAlign = wParam;
                     break;
             }
             break;

         case WM_LBUTTONUP:
             ptCurrent.x = LOWORD(lParam);
             ptCurrent.y = HIWORD(lParam);
             ShowString(hWnd);
             break;

         case WM_DESTROY:
             PostQuitMessage(0);
             break;

         default:
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (0L);
 }


 TEXTCOL.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\TEXTCOL.C

 /*
  *  SetTextColor
  *  TEXTCOL.C,
  *
  *  This program demonstrates the use of the function SetTextColor.
  *  SetTextColor changes the color of future text output.
  *  This program gets a DC and outputs black text on a white backround.
  *  Next the text backround is changed to black.  The text is changed to
  *  white using the function SetTextColor.  Finally, the white text is
  *  output to the screen.
  *
  */

 #include <windows.h>
 #include <string.h>

 char  *szMessage = "This is the text color before invoking SetTextColor.";
 char  *szWhite = "The text color is now white.";

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   HWND       hWnd;
   HDC        hDC;
   DWORD      rgbcolor;
   DWORD      dwblack = RGB (0x00, 0x00, 0x00);
   DWORD      dwwhite = RGB (0xff, 0xff, 0xff);
   WNDCLASS   Class;

   Class.hCursor        = LoadCursor (NULL, IDC_ARROW);
   Class.lpszMenuName   = (LPSTR)NULL;
   Class.lpszClassName  = (LPSTR)"Window";
   Class.hbrBackground  = (HBRUSH)GetStockObject (BLACK_BRUSH);
   Class.hInstance      = hInstance;
   Class.style          = CS_HREDRAW | CS_VREDRAW;
   Class.lpfnWndProc    = DefWindowProc;

   if (!RegisterClass ( (LPWNDCLASS)&Class))
     return FALSE;

   hWnd = CreateWindow ( (LPSTR)"Window",
                       (LPSTR)"SetTextColor",
                       WS_TILEDWINDOW,
                       20, 20, 400, 200,
                       (HWND)NULL,        /* no parent */
                       (HMENU)NULL,       /* use class menu */
                       (HANDLE)hInstance, /* handle to window instance */
                       (LPSTR)NULL);      /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   hDC = GetDC (hWnd);

   TextOut (hDC, 0, 0, (LPSTR)szMessage, strlen (szMessage));

   SetBkColor (hDC, dwblack);

   rgbcolor = SetTextColor (hDC, dwwhite);

   TextOut (hDC, 0, 15, (LPSTR)szWhite, strlen (szWhite));
   ReleaseDC (hWnd, hDC);

   MessageBox (GetFocus (), (LPSTR)"Program Finished",
       (LPSTR)"SetTextColor", MB_OK);

   return 0;
   }


 TEXTOUT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TEXT\TEXTOUT.C

 /*
  *  TextOut
  *  textout.c
  *
  *  This Program outputs text to the upper left hand corner of the client
  *  area using the TextOut function. The TextOut function outputs a character
  *  string on the specified display, using the currently selected font.
  *  The starting position of the string is given by the X and Y parameters.
  *
  */

 #include <windows.h>
 #include <string.h>

 char  *szTextOutMsg = "The TextOut function wrote this text.";


 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
   {
   HWND  hWnd;         /* Handle to the parent window */
   HDC   hDC;          /* Display context of client area */
   BOOL  flag;         /* Return value for TextOut function*/
   WNDCLASS   Class;

   Class.hCursor        = LoadCursor (NULL, IDC_ARROW);
   Class.lpszMenuName   = (LPSTR)NULL;
   Class.lpszClassName  = (LPSTR)"Window";
   Class.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   Class.hInstance      = hInstance;
   Class.style          = CS_HREDRAW | CS_VREDRAW;
   Class.lpfnWndProc    = DefWindowProc;

   if (!RegisterClass ( (LPWNDCLASS)&Class))
     return FALSE;

   hWnd = CreateWindow ( (LPSTR)"Window",
                       (LPSTR)"TextOut",
                       WS_TILEDWINDOW,
                       20, 20, 400, 200,
                       (HWND)NULL,
                       (HMENU)NULL,
                       (HANDLE)hInstance,
                       (LPSTR)NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   hDC = GetDC (hWnd);

   flag = TextOut (hDC, 0, 0, (LPSTR)szTextOutMsg, strlen (szTextOutMsg));

   ReleaseDC (hWnd, hDC);

   if (flag == TRUE)
     MessageBox (hWnd, (LPSTR)"The TextOut fuction returns TRUE",
         (LPSTR)"Done", MB_OK);
   return 0;
   }


 TRANSACC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\ACCELL\TRANSACC.C

 /*
  *  TranslateAccelerator
  *  transacc.c
  *
  * This program demonstrates the use of the function TranslateAccelerator.
  * When the function keys F9 or F10 are pressed then a message box appears
  * which notifies the user that the TranslateAccelerator function has
  * successfully converted and dispatched an accelerator message.
  *
  * All messages to this application are first passed to the
  * TranslateAccelerator function.  TranslateAccelerator will compare
  * the message to a predefined accelerator to see if they match.  If
  * the message doesn't match then TranslateAccelerator returns a 0,
  * and the message will be processed normally using TranslateMessage
  * and DispatchMessage.  If they do match, the message is an accelerator,
  * and the routine translates the message into a WM_COMMAND or
  * WM_SYSCOMMAND message.
  */

 #include <windows.h>
 #include "transacc.h"

 static HANDLE hInst;

 int     PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE    hInstance, hPrevInstance;
 LPSTR     lpszCmdLine;
 int       cmdShow;
   {
   MSG       msg;
   HWND      hWnd;
   BOOL      bDecrementDisplayCount = 0;
   BOOL      bIncrementDisplayCount = 1;
   short     nResult;
   WNDCLASS  Class;

   Class.lpfnWndProc    = TransAccelWindowProc;
   Class.hCursor        = LoadCursor (NULL, IDC_ARROW);
   Class.lpszMenuName   = MAKEINTRESOURCE (TRANSACCELMENU1);
   Class.lpszClassName  = (LPSTR)"Window";
   Class.hbrBackground  = (HBRUSH)GetStockObject (WHITE_BRUSH);
   Class.hInstance      = hInstance;
   Class.style          = CS_HREDRAW | CS_VREDRAW;

   if (!RegisterClass ( (LPWNDCLASS)&Class))
     return FALSE;

   hInst = hInstance;

   hWnd = CreateWindow ( (LPSTR)"Window",
                      (LPSTR)"ShowCaret",
                      WS_OVERLAPPEDWINDOW,
                      CW_USEDEFAULT,          /* x         */
                      CW_USEDEFAULT,          /* y         */
                      CW_USEDEFAULT,          /* width     */
                      CW_USEDEFAULT,          /* height    */
                      (HWND)NULL,             /* no parent */
                      (HMENU)NULL,            /* use class menu */
                      (HANDLE)hInstance,      /* handle to window instance */
                      (LPSTR)NULL);           /* no params to pass on */

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
     if (TranslateAccelerator (msg.hwnd, LoadAccelerators (hInstance,
         MAKEINTRESOURCE (TRANSACCELMENU1)), (LPMSG) & msg) == 1)
       MessageBox (hWnd, (LPSTR)"TranslateAccelerator processed a message",
           (LPSTR)"Done", MB_OK);
     else
       {
       TranslateMessage ( (LPMSG) & msg);
       DispatchMessage ( (LPMSG) & msg);
       }

   return TRUE;
   }

 long    FAR PASCAL TransAccelWindowProc (hWnd, message, wParam, lParam)
 HWND     hWnd;
 unsigned message;
 WORD     wParam;
 LONG     lParam;
   {
   switch (message)
     {
     case WM_COMMAND:
       TransAccelMenuProc (hWnd, wParam);
       break;

     default:
       return (DefWindowProc (hWnd, message, wParam, lParam));
       break;
     }
   return (0L);
   }

 void TransAccelMenuProc (hWnd, wId)
 HWND hWnd;
 WORD wId;
   {
   HMENU hMenu;

   switch (wId)
     {
     case ID_NEXT:
       hMenu = GetMenu (hWnd);  /*  Get the old menu  */
       DestroyMenu (hMenu);     /*  Get rid of it  */
       hMenu = LoadMenu (hInst, MAKEINTRESOURCE (TRANSACCELMENU2));
       SetMenu (hWnd, hMenu);
       DrawMenuBar (hWnd);
       break;

     case ID_PREV:
       hMenu = GetMenu (hWnd);  /*  Get the old menu  */
       DestroyMenu (hMenu);     /*  Get rid of it  */
       hMenu = LoadMenu (hInst, MAKEINTRESOURCE (TRANSACCELMENU1));
       SetMenu (hWnd, hMenu);
       DrawMenuBar (hWnd);
       break;
     }
   }


 TRNCOMCH.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\TRNCOMCH.C

 /*
  *  TransmitCommChar
  *  trncomch.c
  *
  *  This program demonstrates the use of the function TransmitCommChar.
  *  It puts the specified character at the header of the transmit queue
  *  of the communication device for immediate transmission.
  *
  *  Note: Depending on how com1 is set up, this may have unusual side
  *  effects.
  *
  */

 #include <windows.h>
 #include <stdio.h>

 int  PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  cmdShow;
 {
   HWND  hWnd;
   short  nCid;            /* identifer for open com device */
   short  nFlag;           /* Result of the TransmitCommChar function */
   DCB   dcb;             /* The device control block */
   BYTE  nChar;           /* Byte value of the char transmitted */
   char  szBuffer[40];
   WNDCLASS   wcClass;

   wcClass.hCursor        = LoadCursor (NULL, IDC_ARROW);
   wcClass.hIcon          = LoadIcon (hInstance, "WindowIcon");
   wcClass.lpszMenuName   = NULL;
   wcClass.lpszClassName  = "Trncomch";
   wcClass.hbrBackground  = GetStockObject (WHITE_BRUSH);
   wcClass.hInstance      = hInstance;
   wcClass.style          = CS_HREDRAW | CS_VREDRAW;
   wcClass.lpfnWndProc    = DefWindowProc;
   wcClass.cbClsExtra     = 0;
   wcClass.cbWndExtra     = 0;

   RegisterClass ( (LPWNDCLASS) & wcClass);

   hWnd = CreateWindow ("Trncomch", "Transmitting Characters",
       WS_OVERLAPPEDWINDOW, 50, 50, 600, 250,
       NULL, NULL, hInstance, NULL);

   ShowWindow (hWnd, cmdShow);
   UpdateWindow (hWnd);

   nCid = OpenComm ("COM1", 20, 20);

   if (nCid < 0)
   {
     MessageBox (hWnd, "Com port not opened!!", "OpenComm", MB_OK);
     return 0;
   }

 /* set the device control block of the communication device */
   if (GetCommState (nCid, (DCB FAR * ) & dcb) >= 0)
   {
     dcb.BaudRate = 9600;
     dcb.ByteSize = 8;
     dcb.StopBits = ONESTOPBIT;
     dcb.Parity   = NOPARITY;
     dcb.fRtsflow = FALSE;
     dcb.fDtrflow = FALSE;
     dcb.fOutX    = FALSE;
     dcb.fInX     = FALSE;
     dcb.fNull    = FALSE;
     dcb.XonLim   = 1;
     dcb.XoffLim  = 20;
   }

   SetCommState ( (DCB FAR * ) & dcb);

   MessageBox (hWnd, "Ready to transmit char", "Ready?", MB_OK);

 /* Sending the alphabets over to a dumb terminal immediately. nFlag
    * is negative if the character cannot be transmitted.
    */
   for (nChar = 65; nChar <= 90; nChar++)
   {
     nFlag = TransmitCommChar (nCid, nChar);
     if (!nFlag)
     {
       sprintf (szBuffer, "Character %c transmitted", nChar);
       MessageBox (hWnd, szBuffer, "OK", MB_OK);
     }
     else
     {
       sprintf (szBuffer, "Character %c not transmitted", nChar);
       MessageBox (hWnd, szBuffer, "FAIL", MB_OK);
     }
   }

 /* must close the communication device before leaving the program */
   CloseComm (nCid);
   return 0;
 }




 TRNSLTMG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\TRNSLTMG.C

 /*
  *   TranslateMessage
  *   trnsltmg.c
  *
  *   This program demonstrates the function TranslateMessage.  A virtual-
  *   keystroke message is translated into an ascii character message and
  *   posted to the application queue, to be read the next time the
  *   application calls the GetMessage function.  The character is finally
  *   displayed on the screen.  This sequence is repeated until a
  *   WM_DESTROY message is received (the window is closed by the user).
  *
  *   After testing this program, try removing the TranslateMessage function.
  *   You will find that the keyboard will appear dead.  None of the
  *   virtual-keystroke messages are translated into character messages.
  *   Mouse input will still be available even Without TranslateMessage.
  *
  */

 #include <windows.h>
 #include <string.h>
 #include <stdio.h>

 #define FIRST_ASCII_CHAR  0
 #define LAST_ASCII_CHAR   127

 /* Forward references */

 int  PASCAL      WinMain(HANDLE, HANDLE, LPSTR, int);
 BOOL            TranslateMsgInit(HANDLE);
 void PASCAL     PaintCharacter(HWND);
 long  FAR PASCAL TranslateMsgWndProc(HWND, unsigned, WORD, LONG);

 BYTE chAsciiChar = 255;             /* Current keyboard character */

 int  PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, CmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  CmdShow;
 {
   MSG    msg;
   HANDLE hInst;
   HWND   hWnd;
   BOOL   bInit;

   if (!hPrevInstance)
     bInit = TranslateMsgInit(hInstance);

   hInst = hInstance;

   hWnd = CreateWindow((LPSTR)"TranslateMessage",
       (LPSTR)"TranslateMessage",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible */
   ShowWindow(hWnd, CmdShow);
   UpdateWindow(hWnd);

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }

   return (int)msg.wParam;
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL TranslateMsgInit(hInstance)
 HANDLE hInstance;
 {
   WNDCLASS   rTranslateMsgClass;

   rTranslateMsgClass.hCursor        = LoadCursor(NULL, IDC_ARROW );
   rTranslateMsgClass.hIcon          = LoadIcon(hInstance, NULL);
   rTranslateMsgClass.lpszMenuName   = (LPSTR)NULL;
   rTranslateMsgClass.lpszClassName  = (LPSTR)"TranslateMessage";
   rTranslateMsgClass.hbrBackground  = (HBRUSH)GetStockObject(WHITE_BRUSH);
   rTranslateMsgClass.hInstance      = hInstance;
   rTranslateMsgClass.style          = CS_HREDRAW | CS_VREDRAW;
   rTranslateMsgClass.lpfnWndProc    = TranslateMsgWndProc;

   if (!RegisterClass((LPWNDCLASS) & rTranslateMsgClass))
 /* Initialization failed.
      * Windows will automatically deallocate all allocated memory.
      */
     return FALSE;

   return TRUE;        /* Initialization succeeded */
 }


 /* Every message for this window will be delevered right here.         */
 long  FAR PASCAL TranslateMsgWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_PAINT:
     PaintCharacter(hWnd);
     break;
   case WM_CHAR:
 /* The value of the key is stored in the low order byte of wParam */
     chAsciiChar = LOBYTE(wParam);
     InvalidateRect(hWnd, (LPRECT)NULL, TRUE);
     break;
   case WM_DESTROY:
     PostQuitMessage(0);
     break;
   }
   return(0L);
 }


 void PASCAL PaintCharacter(hWnd)
 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC         hDC;
   char  szOutBuff [80];

   hDC = BeginPaint(hWnd, (LPPAINTSTRUCT) & ps);

   if ((chAsciiChar >= FIRST_ASCII_CHAR) && (chAsciiChar <= LAST_ASCII_CHAR))
   {
     sprintf(szOutBuff, "The '%c' key was pressed.",  chAsciiChar);
     TextOut(hDC, 30, 30, (LPSTR)szOutBuff, strlen(szOutBuff));
   }
   else
     TextOut(hDC, 30, 30, (LPSTR)"Please press a key", 18);
   EndPaint(hWnd, (LPPAINTSTRUCT) & ps);
 }




 TTY.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TTY\TTY.C

 /*  TTY.c
     a very simple sample terminal application. It demonstrates
     the basics in the use of the Windows Comm functions. It also
     shows the basic structure for a terminal program.
     Currently, there are a number of things that are hard coded,
     which could be made settable in a dialog box. These can be
     found in the Terminal data section below. They are things like
     the background and text colors, the background brush, and the
     font to be used. Also, the baud rate and other communication
     settings are hard coded. You can experiment with different
     settings, or change them just to match your available serial
     connection.

     Microsoft makes no claims to the correctness or operation of
     this code. It is provided for example and learning purposes
     only.

     Copyright (c) Microsoft 1985,1986,1987,1988,1989 */

 #include "windows.h"
 #include "TTY.h"

 char szAppName[10];
 char szAbout[10];
 char szMessage[15];
 int MessageLength;

 /* Terminal data */
 typedef char cpt[2];      // point array of char sized values

 #define cpX 0
 #define cpY 1

 #define PortSetting  "com1"
 #define CommSettings "com1:96,n,8,1"
 #define BufMax 160
 HWND hTTYWnd;
 char MsgBuff[BufMax + 1];   // Buffer to hold incoming characters
 char sScrBuff[25][81];      // Array of characters on TTY
 char cLastLine;       // Index of last line on TTY in the array
 char cCurrPos;        // Current TTY output position
 BOOL bConnected;      // Flag to indicate if connected
 int TTYCharWidth, TTYCharHeight;    // width and height of TTY font chars
 DCB CommDCB;        // DCB for comm port
 COMSTAT CommStat;      // COMSTAT info buffer for comm port

 DWORD TTYbkRGB = RGB(0,0,0);    // background color
 DWORD TTYtextRGB = RGB(255,255,255);  // text color
 #define TTY_BRUSH BLACK_BRUSH    // background brush
 #define TTY_FONT DEVICEDEFAULT_FONT  // font used for display

 char sTemp[256];
 HFONT hOldFont;

 static HANDLE hInst;
 FARPROC lpprocAbout;

 long FAR PASCAL TTYWndProc(HWND, unsigned, WORD, LONG);

 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     if (message == WM_COMMAND
   || message == WM_LBUTTONDOWN) {
         EndDialog( hDlg, TRUE );
         return TRUE;
         }
     else if (message == WM_INITDIALOG)
         return TRUE;
     else return FALSE;
 }

 SetupTTYDC(HWND hWnd, HDC hDC)
 {
     RECT rClRect;

     hOldFont = SelectObject(hDC,GetStockObject(TTY_FONT));
     GetClientRect(hWnd,&rClRect);
     SetViewportOrg(hDC,0,rClRect.bottom-TTYCharHeight*25);
     SetTextColor(hDC,TTYtextRGB);
     SetBkColor(hDC,TTYbkRGB);
     SetBkMode(hDC,OPAQUE);

 }

 ResetTTYDC(HWND hWnd, HDC hDC)
 {
     SelectObject(hDC,hOldFont);
 }

 char *GetTTYLine(char ndx)    // get ptr to text for give line
 {
     char pos;

     pos = cLastLine + ndx + 1;
     pos = pos > 24 ? (pos % 24)-1 : pos;
     return(sScrBuff[pos]);
 }

 POINT TTYScrPos(char X, char Y)   // get window pos from TTY pos
 {
     POINT ScrPos;

     ScrPos.x = X * TTYCharWidth;
     ScrPos.y = Y * TTYCharHeight;
     return(ScrPos);
 }

 // process incoming text to tty window - simulate tty actions
 void putTTY(HWND hWnd, HDC hDC, WORD wParam, LPSTR lParam)
 {
     short i,j;
     POINT ptTTYPos;
     char *sBuffer;
     char len = 0;
     RECT rClRect;
     char *psLine;
     short iLinesOut = 0;

     sBuffer = &sScrBuff[cLastLine][cCurrPos];

     for(i=0;i<wParam;i++){
   switch(lParam[i]) {

   case '\r': // return
       // move to the start of the line
       cCurrPos = 0;
       len = 0;

       break;

   case '\b': // backspace

       // (ok, so most of this should be a function since it is
       //    repeated later)
       // Note: it is easier to go ahead and display the text
       //  up to this point for things such as backspace. This
       //  will apply to other things, like arrow keys, tabs, etc.

       // scroll screen by number of lines received
       if(iLinesOut > 0) {
     // scroll iLinesOut lines
     ScrollWindow(hWnd,0,-(TTYCharHeight * iLinesOut),NULL,NULL);
     rClRect.top = TTYCharHeight * (24 - iLinesOut);
     rClRect.bottom = TTYCharHeight*25;
     rClRect.left = 0;
     rClRect.right = TTYCharWidth * 80;
     FillRect(hDC,&rClRect,GetStockObject(TTY_BRUSH));

       }

       // display lines in scrolled area previous to current line
       for(j = 1;j<=iLinesOut;j++) {
     // TextOut line cLastLine - j;
     psLine = GetTTYLine(24 - j);
     ptTTYPos = TTYScrPos(0,24 - j);
     TextOut(hDC,
       ptTTYPos.x,
       ptTTYPos.y,
       psLine,
       strlen(psLine));

       }
       iLinesOut = 0;

       if(len > 0){
     // display current line
     ptTTYPos = TTYScrPos(cCurrPos,24);
     TextOut(hDC,
         ptTTYPos.x,
         ptTTYPos.y,
         sBuffer,
         len);
     cCurrPos += len;
       }
       len = 0;

       // move back one space
       if(cCurrPos > 0) {
     --cCurrPos;
     ptTTYPos = TTYScrPos(cCurrPos,24);
     TextOut(hDC,
         ptTTYPos.x,
         ptTTYPos.y,
         " ",
         1);
       }
       break;

   case '\n': // new line

       // "scroll" the window
       ++iLinesOut; // increment lines to scroll
       ++cLastLine;
       if(cLastLine > 24) cLastLine = 0;

       // clear the new line
       sBuffer = &sScrBuff[cLastLine][0];
       for(j=0;j<80;j++) sBuffer[j] = '\0';
       len = 0;

       break;

   default:
       //add char to buffer
       if(cCurrPos < 80){
     sBuffer[len] = lParam[i];
     ++len;
       }
       break;
   }
     }

     // scroll screen by number of lines received
     if(iLinesOut > 0) {
   // scroll iLinesOut lines
   ScrollWindow(hWnd,0,-(TTYCharHeight * iLinesOut),NULL,NULL);
   rClRect.top = TTYCharHeight * (24 - iLinesOut);
   rClRect.bottom = TTYCharHeight*25;
   rClRect.left = 0;
   rClRect.right = TTYCharWidth * 80;
   FillRect(hDC,&rClRect,GetStockObject(TTY_BRUSH));

     }

     // display lines in scrolled area previous to current line
     for(j = 1;j<=iLinesOut;j++) {
   // TextOut line cLastLine - j;
   psLine = GetTTYLine(24 - j);
   ptTTYPos = TTYScrPos(0,24 - j);
   TextOut(hDC,
     ptTTYPos.x,
     ptTTYPos.y,
     psLine,
     strlen(psLine));

     }

     if(len > 0){
   // display current line
   ptTTYPos = TTYScrPos(cCurrPos,24);
   TextOut(hDC,
       ptTTYPos.x,
       ptTTYPos.y,
       sBuffer,
       len);
   cCurrPos += len;
     }
 }


 void TTYPaint(HDC hDC )    // repaint the text in the tty
 {
     char *psLine;
     POINT ptTTYPos;
     register int i;

     for(i=0;i<25;i++){
   psLine = GetTTYLine(i);
   ptTTYPos = TTYScrPos(0,i);
   TextOut(hDC,
     ptTTYPos.x,
     ptTTYPos.y,
     psLine,
     strlen(psLine));
     }
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL TTYInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS  pTTYClass;

     /* Load strings from resource */
     LoadString( hInstance, IDSNAME, (LPSTR)szAppName, 10 );
     LoadString( hInstance, IDSABOUT, (LPSTR)szAbout, 10 );
     MessageLength = LoadString( hInstance, IDSTITLE, (LPSTR)szMessage, 15 );

     pTTYClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pTTYClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pTTYClass->hIcon        = LoadIcon( hInstance, MAKEINTRESOURCE(TTYICON) )
     pTTYClass->lpszMenuName   = (LPSTR)"TTYMENU";
     pTTYClass->lpszClassName  = (LPSTR)szAppName;
     pTTYClass->hbrBackground  = (HBRUSH)GetStockObject( TTY_BRUSH );
     pTTYClass->hInstance      = hInstance;
     pTTYClass->style        = CS_HREDRAW | CS_VREDRAW | CS_OWNDC
         | CS_BYTEALIGNCLIENT;
     pTTYClass->lpfnWndProc    = TTYWndProc;

     if (!RegisterClass( (LPWNDCLASS)pTTYClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pTTYClass );
     return TRUE;        /* Initialization succeeded */
 }


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HMENU hMenu;
     RECT rClRect, rWndRect;
     short iXExtra,iYExtra;
     short iNumRead,iError;

     if (!hPrevInstance) {
         /* Call initialization procedure if this is the first instance */
   if (!TTYInit( hInstance ))
             return FALSE;
         }
     else {
         /* Copy data from previous instance */
         GetInstanceData( hPrevInstance, (PSTR)szAppName, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szAbout, 10 );
         GetInstanceData( hPrevInstance, (PSTR)szMessage, 15 );
         GetInstanceData( hPrevInstance, (PSTR)&MessageLength, sizeof(int) );
         }

     hWnd = CreateWindow((LPSTR)szAppName,
                         (LPSTR)szMessage,
                         WS_TILEDWINDOW,
       CW_USEDEFAULT,    /*  x - ignored for tiled windows */
       CW_USEDEFAULT,    /*  y - ignored for tiled windows */
       CW_USEDEFAULT,    /* cx - ignored for tiled windows */
       CW_USEDEFAULT,    /* cy - ignored for tiled windows */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Save instance handle for DialogBox */
     hInst = hInstance;

     /* Bind callback function with module instance */
     lpprocAbout = MakeProcInstance( (FARPROC)About, hInstance );

     /* Insert "About..." into system menu */
     hMenu = GetSystemMenu(hWnd, FALSE);
     ChangeMenu(hMenu, 0, NULL, 999, MF_APPEND | MF_SEPARATOR);
     ChangeMenu(hMenu, 0, (LPSTR)szAbout, IDSABOUT, MF_APPEND | MF_STRING);

     /* Make window visible according to the way the app is activated */
     GetWindowRect(hWnd,&rWndRect);
     GetClientRect(hWnd,&rClRect);
     iXExtra = (rWndRect.right-rWndRect.left)-(rClRect.right-rClRect.left);
     iYExtra = (rWndRect.bottom-rWndRect.top)-(rClRect.bottom-rClRect.top);
     SetWindowPos(hWnd,NULL,0,0,
     TTYCharWidth*80 + iXExtra,
     TTYCharHeight*25 + iYExtra,
     SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* Polling messages from event queue */
     while(TRUE){
   // if messages pending, process them
   if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
       if(msg.message == WM_QUIT) break;
       TranslateMessage((LPMSG)&msg);
       DispatchMessage((LPMSG)&msg);
   } else {
       // otherwise check the comm port and process any available
       // characters. you could also use a timer instead, and have
       // the timer case of the wndproc check the port.
       if(bConnected){
     // get the CommStat record and clear any error condition
     GetCommError(CommDCB.Id,&CommStat);
     // get the number of characters available
     iNumRead = CommStat.cbInQue;
     if(iNumRead > 0) {
         // get the number of characters rounded to the buffer size
         if(iNumRead > BufMax) iNumRead = BufMax;
         iNumRead = ReadComm(CommDCB.Id,MsgBuff,
           iNumRead);
         // check for errors
         if(iNumRead < 0) {
       iNumRead = abs(iNumRead);
       iError = GetCommError(CommDCB.Id,&CommStat);
       // clear the event mask
       GetCommEventMask(CommDCB.Id,0xFFFF);
       itoa(iError,sTemp,10);
       // display what the error was
       switch(iError){
       case CE_BREAK:
           MessageBox(GetFocus(), sTemp, "CE_BREAK!",MB_OK);
           break;
       case CE_CTSTO:
           MessageBox(GetFocus(), sTemp, "CE_CTSTO!",MB_OK);
           break;
       case CE_DNS:
           MessageBox(GetFocus(), sTemp, "CE_DNS!",MB_OK);
           break;
       case CE_DSRTO:
           MessageBox(GetFocus(), sTemp, "CE_DSTRO!",MB_OK);
           break;
       case CE_FRAME:
           MessageBox(GetFocus(), sTemp, "CE_FRAME!",MB_OK);
           break;
       case CE_IOE:
           MessageBox(GetFocus(), sTemp, "CE_IOE!",MB_OK);
           break;
       case CE_MODE:
           MessageBox(GetFocus(), sTemp, "CE_MODE!",MB_OK);
           break;
       case CE_OOP:
           MessageBox(GetFocus(), sTemp, "CE_OOP!",MB_OK);
           break;
       case CE_OVERRUN:
           MessageBox(GetFocus(), sTemp, "CE_OVERRUN!",MB_OK);
           break;
       case CE_PTO:
           MessageBox(GetFocus(), sTemp, "CE_PTO!",MB_OK);
           break;
       case CE_RLSDTO:
           MessageBox(GetFocus(), sTemp, "CE_RLSDTO!",MB_OK);
           break;
       case CE_RXOVER:
           MessageBox(GetFocus(), sTemp, "CE_RXOVER!",MB_OK);
           break;
       case CE_RXPARITY:
           MessageBox(GetFocus(), sTemp, "CE_RXPARITY!",MB_OK);
           break;
       case CE_TXFULL:
           MessageBox(GetFocus(), sTemp, "CE_TXFULL!",MB_OK);
           break;
       }
         }
         // send the characters to the tty window for processing
         SendMessage(hTTYWnd,COMM_CHARS,
         iNumRead,(LONG)(LPSTR)MsgBuff);
     }


       }
   }
     }

     return (int)msg.wParam;
 }


 /* Procedures which make up the window class. */
 long FAR PASCAL TTYWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;
     register int i,j;
     TEXTMETRIC Metrics;
     HDC hDC;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:  // repaint the tty window
   BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
   hDC = ps.hdc;
   SetupTTYDC(hWnd,hDC);

   TTYPaint( hDC );

   ResetTTYDC(hWnd,hDC);
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     case WM_CREATE:  // initialize the comm and tty parameters
   /* initialize screen buffer to nulls */
   for(i=0;i<25;i++)
       for(j=0;j<81;j++)
     sScrBuff[i][j] = '\0';
   /* initialize line and position to zero */
   cLastLine = 0;
   hDC = GetDC(hWnd);
   SetupTTYDC(hWnd,hDC);
   GetTextMetrics(hDC,&Metrics);
   ResetTTYDC(hWnd,hDC);
   ReleaseDC(hWnd,hDC);
   cCurrPos = 0;
   TTYCharWidth = Metrics.tmMaxCharWidth;
   TTYCharHeight = Metrics.tmHeight + Metrics.tmExternalLeading;
   bConnected = FALSE;
   hTTYWnd = hWnd;

   break;

     case WM_CLOSE:
   // disconnect if still connected
   if(bConnected)SendMessage(hWnd,WM_COMMAND,TTYCONNECT,0L);
   // go ahead and close down
   DefWindowProc( hWnd, message, wParam, lParam );
   break;

     case WM_COMMAND:
   switch(wParam){

         case IDSABOUT:
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             break;

   case TTYEXIT:
       PostMessage(hWnd,WM_CLOSE,0,0L);
       break;

   case TTYCONNECT:
       // connect to port if not already connected
       if(!bConnected){
     if(OpenComm(PortSetting,1024,128)) break;
     if(BuildCommDCB(CommSettings,&CommDCB)) break;

     FlushComm(CommDCB.Id,0);
     FlushComm(CommDCB.Id,1);

     CommDCB.fInX = TRUE;
     CommDCB.fOutX = FALSE;
     CommDCB.XonChar = 0x11;
     CommDCB.XoffChar = 0x13;
     CommDCB.XonLim = 50;
     CommDCB.XoffLim = 500;

     if(SetCommState(&CommDCB))break;
     bConnected = TRUE;
     MessageBox(hWnd,"Connection was successful.","",MB_OK);
       }else{
     // otherwise disconnect
     FlushComm(CommDCB.Id,0);
     FlushComm(CommDCB.Id,1);
     CloseComm(CommDCB.Id);
     MessageBox(hWnd,"Connection closed.","",MB_OK);
     bConnected = FALSE;
       }
       break;
   case TTYSETTINGS:
       // settings dialog
       i=1;  // this does nothing right now
       break;
   }
   break;

     case WM_CHAR:
   if(!bConnected) break;
   i = GetCommError(CommDCB.Id,&CommStat);
         if(i != 0) {
       itoa(i,sTemp,10);
       MessageBox(GetFocus(), sTemp, "Comm Read Error!",MB_OK);
         }

   WriteComm(CommDCB.Id,&wParam,1);
   break;

     case COMM_CHARS:
   if(wParam > 0) {
       hDC = GetDC(hWnd);
       SetupTTYDC(hWnd,hDC);

       putTTY(hWnd,hDC,wParam,(LPSTR)lParam);

       ResetTTYDC(hWnd,hDC);
       ReleaseDC(hWnd,hDC);
   }
   break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 UPDTWIN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\UPDTWIN.C

 /*
  *   UpdateWindow
  *   updtwin.c
  *
  *   This program demonstrates the use of the function UpdateWindow.
  *   UpdateWindow sends a WM_PAINT message directly to the paint procedure
  *   of the given window if the update region for the window is not empty.
  *   The paint procedure invokes the TextOut function to let the operator
  *   know that the WM_PAINT message is being processed.  A message box is
  *   then shown to let the operator know that the call to UpdateWindow is
  *   complete.
  *
  */

 #include "windows.h"
 #include "string.h"

 BOOL PASCAL SampleInit(HANDLE , HANDLE, int);
 BOOL PASCAL SamplePaint(HANDLE);
 long  FAR PASCAL SampleWndProc(HWND, unsigned, WORD, LONG);

 static HANDLE  hInst;  /* Can be used througout the program but not normally
                         * passed to other intances */

 int  PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, nCmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int  nCmdShow;
 {
   HWND  hWnd;
   MSG   msg;
   HWND hWindow;    /* For use in the UpdateWindow demonstration section */

   if (!hPrevInstance)
     SampleInit(hInstance, hPrevInstance, nCmdShow);

   hInst = hInstance;                      /* So window procedures can use */
   hWnd = CreateWindow((LPSTR)"UpdateWindow",
       (LPSTR)"UpdateWindow",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,        /* no parent */
   (HMENU)NULL,       /* use class menu */
   (HANDLE)hInstance, /* handle to window instance */
   (LPSTR)NULL        /* no params to pass on */
   );

 /* Make window visible according to the way the app is activated */
   ShowWindow(hWnd, nCmdShow);
   hWindow = GetActiveWindow();
   UpdateWindow( hWindow ); /* Send a WM_PAINT message directly to the
                               * window procedure, bypassing the application
                                 * queue.   */
   MessageBox(hWindow,
       (LPSTR)"UpdateWindow and processed a WM_PAINT message.",
       (LPSTR)"I called ...",
       MB_OK | MB_SYSTEMMODAL );

 /* Polling messages from event queue */
   while (GetMessage((LPMSG) & msg, NULL, 0, 0))
   {
     TranslateMessage((LPMSG) & msg);
     DispatchMessage((LPMSG) & msg);
   }
   return (int)msg.wParam;
 }


 /* Procedure called when the application is loaded for the first time */
 BOOL PASCAL SampleInit( hInstance, hPrevInstance, nCmdShow )
 HANDLE hInstance, hPrevInstance;
 int  nCmdShow;
 {
   PWNDCLASS   pSampleClass;

   pSampleClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

   pSampleClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
   pSampleClass->hIcon        = LoadIcon( hInstance, NULL);
   pSampleClass->lpszMenuName   = (LPSTR)NULL;
   pSampleClass->lpszClassName  = (LPSTR)"UpdateWindow";
   pSampleClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
   pSampleClass->hInstance      = hInstance;
   pSampleClass->style          = CS_HREDRAW | CS_VREDRAW;
   pSampleClass->lpfnWndProc    = SampleWndProc;

   if (!RegisterClass((LPWNDCLASS)pSampleClass))
 /* Initialization failed.
        * Windows will automatically deallocate all allocated memory.
        */
     return FALSE;

   LocalFree((HANDLE)pSampleClass);
   return TRUE;
 }


 /* Every message for this window will be delevered right here.         */
 long  FAR PASCAL SampleWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;
 unsigned  message;
 WORD wParam;
 LONG lParam;
 {
   switch (message)
   {
   case WM_DESTROY:
     PostQuitMessage(0);
     break;

   case WM_PAINT:
     SamplePaint(hWnd);
     break;

   default:
     return DefWindowProc(hWnd, message, wParam, lParam);
     break;
   }
   return(0L);
 }


 BOOL PASCAL SamplePaint(hWnd)
 HWND hWnd;
 {
   PAINTSTRUCT ps;
   HDC         hDC;

   BeginPaint( hWnd, (LPPAINTSTRUCT) & ps );
   hDC = ps.hdc;

   TextOut( hDC, 10, 10,
       (LPSTR)"The TextOut function is called in the paint procedure",
       strlen("The TextOut function is called in the paint procedure"));

   EndPaint( hWnd, (LPPAINTSTRUCT) & ps );

   return TRUE;
 }




 VALFRESP.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\VALFRESP.C

 /*
 Name               : valfresp.c
 Function(s)
 demonstrated in
 this program       : ValidateFreeSpaces()
 Windows version    : 2.03
 Compiler version   : 5.1
 Description        : ValidateFreeSpaces() checks free memory for valid
                      contents, returning the address of the first invalid
                      byte or in the event of no invalid bytes, NULL
 */

 #include <windows.h>
 #include "valfresp.h"

 long FAR PASCAL WndProc (HWND, unsigned, WORD, LONG) ;
 int sprintf(PSTR, PSTR, int);

 static int ErrorCheck;
 static char szResName [] = "ResMenu";

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "valfresp" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = NULL ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "ValidateFreeSpaces",       /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWnd, nCmdShow) ;

      UpdateWindow (hWnd) ;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  static HANDLE hInstance;
  DWORD TotalFree;
  PAINTSTRUCT ps;
  char szBuf[50];
  LPSTR BoneBad;
  HMENU hMenu;
  switch(iMessage)
  {
   case WM_CREATE:
   {
    hInstance = GetWindowWord(hWnd, GWW_HINSTANCE);
    hMenu = LoadMenu(hInstance, "ResMenu");
    SetMenu(hWnd, hMenu);
    DrawMenuBar(hWnd);
    break;
   }
   case WM_PAINT:
   {
    BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
    EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
    break;
   }
   case WM_COMMAND:
   {
    switch(wParam)
    {
     case IDM_EXECUTE:
     {
      BoneBad = ValidateFreeSpaces();
      if (BoneBad!=NULL)
      {
       sprintf(szBuf, "address %iH contains an invalid byte",(unsigned)BoneBad
       MessageBox(GetFocus(), szBuf, "ABORTING!", MB_OK);
      } else
      {
       MessageBox(GetFocus(), "No invalid bytes encountered", "FINISHED", MB_O
      }
     }
    }
    break;
   }
   case WM_DESTROY:
   {
    PostQuitMessage(0);
    break;
   }
   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 VALRECT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\VALRECT.C

 /*
  *   ValidateRect
  *   valrect.c
  *
  *   This program demonstrates the use of the ValidateRect function. The
  *   ValidateRect function subtracts the given rectangle from the update
  *   region, which marks that rectangle for painting. ValidateRect is called
  *   once in this program to cancel the effects of the InvalidateRect
  *   function.  In effect I first set a dirty bit using the InvalidateRect
  *   function.  This dirty bit tells windows that the area containing the
  *   specified rectangle identified by the Rect parameter needs to be
  *   repainted.  I clear the dirty bit with the ValidateRect function so
  *   that the area containing the rectangle is not repainted.  InvalidateRect
  *   is called a second time to demonstrate the effects of the first
  *   ValidateRect function.
  *
  */

 #include "windows.h"

 long FAR PASCAL ValrectWndProc(HWND, unsigned, WORD, LONG);

 /***************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL ValrectInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pValrectClass;

     pValrectClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pValrectClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pValrectClass->hIcon          = LoadIcon( hInstance,NULL);
     pValrectClass->lpszMenuName   = (LPSTR)NULL;
     pValrectClass->lpszClassName  = (LPSTR)"ValidateRect";
     pValrectClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pValrectClass->hInstance      = hInstance;
     pValrectClass->style          = CS_HREDRAW | CS_VREDRAW;
     pValrectClass->lpfnWndProc    = ValrectWndProc;

     if (!RegisterClass( (LPWNDCLASS)pValrectClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pValrectClass );
     return TRUE;        /* Initialization succeeded */
 }
 /***************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     WORD  rectcolor = RGB(0x022,0x022,0x022);
     HDC hDC;         /* handle to display context */
     HBRUSH hMyBrush;    /* handle to brush */
     RECT Rect;         /* structure to hold rectangle coordinates */


          ValrectInit( hInstance );
     hWnd = CreateWindow((LPSTR)"ValidateRect",
                         (LPSTR)"ValidateRect",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,     /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

 /* ----------------------------------------------------------------------- */
 /* Begginning of the ValidateRect section */

 /* create brush to fill rectangle with */
    hMyBrush = CreateSolidBrush(rectcolor);

 /* get handle to display context */
    hDC = GetDC(hWnd);

 /* select brush into display context */
    SelectObject(hDC,hMyBrush);

 /* draw a big rectangle so we can see InvalidateRect's effects */
    Rectangle(hDC,5,5,400,200);

 /* fill Rect with coordinate information for a small rectangle */
    Rect.left = 10;
    Rect.top  = 10;
    Rect.right= 50;
    Rect.bottom=50;

    MessageBox(hWnd,(LPSTR)"a small rectangle then ValidateRect the same \
 small rectangle.  InvalidateRect sets a dirty bit to redraw the rectangle \
 region.  ValidateRect clears the dirty bit so that a call to UpdateWindow \
 will not draw the small rectangle.",
             (LPSTR)"I am about to InvalidateRect...",MB_OK);


 /* invalidate the rect.identified by Rect (TRUE param. causes erase) */
    InvalidateRect(hWnd, (LPRECT)&Rect, (BOOL)TRUE);

 /* Don't draw the rectangle (ie. remove it from the update region) */
    ValidateRect(hWnd, (LPRECT)&Rect);

 /* call UpdateWindow so that draw will take place immediately */
    UpdateWindow(hWnd);


    MessageBox(hWnd,(LPSTR)"Notice that the small rectangle was not drawn",
             (LPSTR)"Done",MB_OK);

    MessageBox(hWnd,(LPSTR)"the small rectangle again, but this time I'm not \
 going to cancel the effects of InvalidateRect with a call to ValidateRect.  \
 This time my call to UpdateWindow will draw the rectangle.",
             (LPSTR)"I am about to InvalidateRect...",MB_OK);

    InvalidateRect(hWnd, (LPRECT)&Rect, (BOOL)TRUE);

    UpdateWindow(hWnd);

    ReleaseDC(hWnd, hDC);

 /* End of the ValidateRect section */
 /* ----------------------------------------------------------------------- */

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }
 /***************************************************************************/

 /* Procedures which make up the window class. */
 long FAR PASCAL ValrectWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 VALRGN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\VALRGN.C

 /*
  *   ValidateRgn
  *   valrgn.c
  *
  *   This program demonstrates the use of the ValidateRgn function. The
  *   ValidateRgn function subtracts the given region from the update
  *   region, which marks that region for painting. ValidateRgn is called
  *   once in this program to cancel the effects of the InvalidateRgn
  *   function.  In effect, I first set a dirty bit using the InvalidateRgn
  *   function.  This dirty bit tells Windows that the area containing the
  *   specified region identified by the hRegion parameter needs to be
  *   repainted.  I clear the dirty bit with the ValidateRgn function so
  *   that the area containing the region is not repainted.  InvalidateRgn
  *   is called a second time to demonstrate the effects of the first
  *   ValidateRgn function.
  *
  */

 #include "windows.h"

 long FAR PASCAL ValrgnWndProc(HWND, unsigned, WORD, LONG);

 /***************************************************************************/

 /* Procedure called when the application is loaded for the first time */
 BOOL ValrgnInit( hInstance )
 HANDLE hInstance;
 {
     PWNDCLASS   pValrgnClass;

     pValrgnClass = (PWNDCLASS)LocalAlloc( LPTR, sizeof(WNDCLASS) );

     pValrgnClass->hCursor        = LoadCursor( NULL, IDC_ARROW );
     pValrgnClass->hIcon          = LoadIcon( hInstance,NULL);
     pValrgnClass->lpszMenuName   = (LPSTR)NULL;
     pValrgnClass->lpszClassName  = (LPSTR)"ValidateRgn";
     pValrgnClass->hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     pValrgnClass->hInstance      = hInstance;
     pValrgnClass->style          = CS_HREDRAW | CS_VREDRAW;
     pValrgnClass->lpfnWndProc    = ValrgnWndProc;

     if (!RegisterClass( (LPWNDCLASS)pValrgnClass ) )
         /* Initialization failed.
          * Windows will automatically deallocate all allocated memory.
          */
         return FALSE;

     LocalFree( (HANDLE)pValrgnClass );
     return TRUE;        /* Initialization succeeded */
 }
 /***************************************************************************/

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     MSG   msg;
     HWND  hWnd;
     HRGN  hRegion;      /* handle to elliptical region */
     HDC hDC;            /* handle to display context */
     HBRUSH hMyBrush;     /* handle to brush */
     RECT Ellipse,       /* structure to hold ellipse coordinates */
          ClearRect;     /* structure to hold client area coordinates */

     ValrgnInit( hInstance );
     hWnd = CreateWindow((LPSTR)"ValidateRgn",
                         (LPSTR)"ValidateRgn",
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       CW_USEDEFAULT,
       (HWND)NULL,     /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

 /* ----------------------------------------------------------------------- */
 /* Begginning of the ValidateRgn section */

 /* get handle to display context */
    hDC = GetDC(hWnd);

 /* fill Ellipse with coordinate information for a small ellipse */
    Ellipse.left = 10;
    Ellipse.top  = 10;
    Ellipse.right= 50;
    Ellipse.bottom=50;

    GetClientRect(hWnd,(LPRECT)&ClearRect);
    InvertRect(hDC,(LPRECT)&ClearRect);
    hRegion = CreateEllipticRgnIndirect((LPRECT)&Ellipse);

    MessageBox(hWnd,(LPSTR)"a small ellipse, then ValidateRgn the same \
 small ellipse. InvalidateRgn sets a dirty bit to redraw the ellipse \
 region.  ValidateRgn clears the dirty bit so that a call to UpdateWindow \
 will not draw the small ellipse.",
             (LPSTR)"I am about to InvalidateRgn...",MB_OK);


 /* invalidate the ellipse identified by hRegion (TRUE param. causes erase) */
    InvalidateRgn(hWnd, (HRGN)hRegion, (BOOL)TRUE);

 /* Don't draw the ellipse (ie. remove it from the update region) */
    ValidateRgn(hWnd, (HRGN)hRegion);

 /* call UpdateWindow so that draw will take place immediately */
    UpdateWindow(hWnd);


    MessageBox(hWnd,(LPSTR)"Notice that the small ellipse was not drawn",
             (LPSTR)"Done",MB_OK);

    MessageBox(hWnd,(LPSTR)"the small ellipse again, but this time I'm not \
 going to cancel the effects of InvalidateRgn with a call to ValidateRgn.  \
 This time my call to UpdateWindow will draw the ellipse.",
             (LPSTR)"I am about to InvalidateRgn...",MB_OK);

    InvalidateRgn(hWnd, (HRGN)hRegion, (BOOL)TRUE);

    UpdateWindow(hWnd);

    ReleaseDC(hWnd, hDC);

 /* End of the ValidateRgn section */
 /* ----------------------------------------------------------------------- */

     /* Polling messages from event queue */
     while (GetMessage((LPMSG)&msg, NULL, 0, 0)) {
         TranslateMessage((LPMSG)&msg);
         DispatchMessage((LPMSG)&msg);
         }

     return (int)msg.wParam;
 }
 /***************************************************************************/

 /* Procedures which make up the window class. */
 long FAR PASCAL ValrgnWndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     PAINTSTRUCT ps;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         BeginPaint( hWnd, (LPPAINTSTRUCT)&ps );
         EndPaint( hWnd, (LPPAINTSTRUCT)&ps );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }


 VERSION.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\VERSION.C

 /*
  *  GetVersion
  *  version.c
  *
  *  This function returns the current version of windows in an unsigned
  *   short integer.  The low byte corresponding to the major version
  *   number and the high byte corresponding to the minor version number.
  *  This function calls the GetVersion function and places the version
  *   number in a message box with the appropriate bytes to convey the
  *   actual current version number.
  *
  */

 #include <windows.h>

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;

 {
    unsigned short version;     /* The Current Version Number.    */
    unsigned short majvers;     /* The Major Version Number.      */
    unsigned short minvers;     /* The Minor Version Number.      */
    char szbuf[14];          /* The Version Number Buffer.     */

    version = GetVersion();     /* Get the Current Version.      */
    majvers = LOBYTE(version);  /* Cast Major Version.            */
    minvers = HIBYTE(version);  /* Cast the Minor Version.         */
    sprintf(szbuf,             /* Place the version number in    */
            "%9s%1d%1s%02d",   /*  the output buffer along with  */
            " Version ",       /*  some explatitory text.        */
            majvers,
            ".",
            minvers);

            /* Create Version Number Message. */

    MessageBox(NULL, (LPSTR)szbuf, (LPSTR)"MS-Windows", MB_OK);

            /* Print Out Version Message.     */

    return 0;         /* Exit With a Successful Return. */

 }


 VIEWPORT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\GRAPHICS\VIEWPORT.C

 /*

 Function(s) demonstrated in this program: GetViewportExt, GetWindowExt,
     OffsetViewportOrg, OffsetWindowOrg, SetViewportExt, SetWindowExt,
    ScaleViewportExt, ScaleWindowExt, SetViewportOrg, SetWindowOrg

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  These functions modify the interface between screen pixels and
     the screen viewport.

 Additional Comments:  The Scale functions (ScaleViewportExt, ScaleWindowExt),
     both take 5 parameters the first is a handle to a display context and
     the next 4 are the numerators and denominators of the fractions that
     will be used to scale the x and y extents.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <math.h>
 #include <stdio.h>
 #include "ViewPort.h"

 #define PI 3.14159265


 char    szRadius  [15];
 HANDLE  hInstMain;
 FARPROC lpProcGetRadius;
 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];
 HWND     hWndMain, hX, hY, hOK2;
 FARPROC  lpProcEnterPoint;
 FARPROC  lpProcNewEnterPoint;
 FARPROC  lpProcOldX;
 FARPROC  lpProcOldY;
 char     szXValue [40];
 char     szYValue [40];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About\0",
 "     This is a sample application to demonstrate the\n\
 use of ViewPort Window Extent functions.",

 "Help Message",
 "     This program uses the Windows functions\n\
 GetViewportExt, GetWindowExt, OffsetViewportOrg,\n\
 OffsetWindowOrg, SetViewportExt, SetWindowExt,\n\
 ScaleViewportExt, SetViewportOrg, SetWindowOrg\n\
 and ScaleWindowExt to modify the relationship\n\
 between the viewport and the screen pixels.  Use\n\
 the menu to request the function, then set the\n\
 variables accordingly.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
     HANDLE  hInstance, hPrevInstance;
     LPSTR  lpszCmdLine;
     int   nCmdShow;
     {
     static char szAppName[] = "ViewPort";
     HWND  hWnd;
     MSG   msg;
     WNDCLASS  wndclass;

     if (!hPrevInstance)  {
         wndclass.style          = CS_HREDRAW | CS_VREDRAW;
         wndclass.lpfnWndProc    = WndProc;
         wndclass.cbClsExtra     = 0;
         wndclass.cbWndExtra     = 0;
         wndclass.hInstance      = hInstance;
         wndclass.hIcon          = NULL; /*LoadIcon (NULL, IDI_ASTERISK);*/
         wndclass.hCursor        = LoadCursor (NULL, IDC_CROSS);
         wndclass.hbrBackground  = GetStockObject (WHITE_BRUSH);
         wndclass.lpszMenuName   = szAppName;
         wndclass.lpszClassName  = szAppName;

         if (!RegisterClass (&wndclass) )
             return FALSE;
     }


     hWnd = CreateWindow (szAppName, "ViewPort",
       WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
     CW_USEDEFAULT, 0, NULL, NULL,
       hInstance, NULL);

     hInstMain = hInstance;
     hWndMain  = hWnd;

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

     lpProcEnterPoint    = MakeProcInstance (EnterPointDlgProc, hInstance);
     lpProcNewEnterPoint = MakeProcInstance (NewEnterPointDlgProc,hInstance);

     while (GetMessage (&msg, NULL, 0, 0))  {
        TranslateMessage (&msg);
        DispatchMessage (&msg);
     }
     return msg.wParam;
 }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
   HWND      hWnd;
   unsigned    iMessage;
   WORD      wParam;
   LONG      lParam;
   {
    HMENU         hMenu;
   static HRGN   hRgnClip;
   static double xXcoord, yYcoord, fRadiusInc=(float)1, fRadius=(float)0,
                  fAngle=(float)0, fAngleShift=(float)1, fMaxRadius,
                  fProportion;
   static short  xClient, yClient;
   HDC          hDC;
   HRGN          hRGN;
   PAINTSTRUCT   ps;
    static WORD   OffViewX, OffViewY, OffWindowX, OffWindowY, SetViewX,
                  SetViewY, SetWindowX, SetWindowY, ScaleViewXnum,
                  ScaleViewYnum, ScaleViewXdenom, ScaleViewYdenom,
                  ScaleWindowXnum, ScaleWindowYnum, ScaleWindowXdenom,
                  ScaleWindowYdenom, SetWindowOrgX, SetWindowOrgY,
                  SetViewportOrgX, SetViewportOrgY;
    DWORD         Check;

   switch (iMessage) {
        case WM_CREATE:
             hMenu = GetSystemMenu (hWnd, FALSE);

             ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                         MF_APPEND | MF_STRING);
             break;

        case WM_SYSCOMMAND:
             switch (wParam) {
                case IDM_ABOUT:
                     ProcessMessage (hWnd, 0);
                     break;
                default:
                     return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
             }
             break;

       case WM_SIZE:
             xClient=LOWORD (lParam);
             yClient=HIWORD (lParam);
             fProportion= ((double) yClient)/ ((double) xClient);
             fMaxRadius = xClient/2.0;
             break;


        case WM_COMMAND:
             switch (wParam) {
                case IDM_CHANGE:
                     lpProcGetRadius = MakeProcInstance(GetRadiusDlgProc,
                                      hInstMain);
                     DialogBox (hInstMain, (LPSTR)"GetAngle", hWnd,
                               lpProcGetRadius);
                     FreeProcInstance (lpProcGetRadius);
                     fAngleShift = atof (szRadius);

                     lpProcGetRadius = MakeProcInstance(GetRadiusDlgProc,
                                      hInstMain);
                     DialogBox (hInstMain, (LPSTR)"GetRadius", hWnd,
                               lpProcGetRadius);
                     FreeProcInstance (lpProcGetRadius);
                     fRadiusInc = atof (szRadius);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_OFFVIEWPORT:
                     bOffsetViewportOrg = TRUE;
                     sprintf (szXValue, "Enter Origin (x,y)");
                     sprintf (szYValue, "OffsetViewportOrg");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     OffViewX = atoi (szXValue);
                     OffViewY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_OFFWINDOW:
                     bOffsetWindowOrg = TRUE;
                     sprintf (szXValue, "Enter Origin (x,y)");
                     sprintf (szYValue, "OffsetWindowOrg");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     OffWindowX = atoi (szXValue);
                     OffWindowY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_SETVIEWPORT:
                     bSetViewportExt = TRUE;
                     sprintf (szXValue, "Enter Extents (x,y)");
                     sprintf (szYValue, "SetViewportExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     SetViewX = atoi (szXValue);
                     SetViewY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_SETEXTENT:
                     bSetWindowExt = TRUE;
                     sprintf (szXValue, "Enter Extents (x,y)");
                     sprintf (szYValue, "SetWindowExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     SetWindowX = atoi (szXValue);
                     SetWindowY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_SCALEVIEW:
                     bScaleViewportExt = TRUE;
                     sprintf (szXValue, "Enter Numerators (x,y)");
                     sprintf (szYValue, "ScaleViewportExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     ScaleViewXnum = atoi (szXValue);
                     ScaleViewYnum = atoi (szYValue);

                     sprintf (szXValue, "Enter Denominators (x,y)");
                     sprintf (szYValue, "ScaleViewportExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     ScaleViewXdenom = atoi (szXValue);
                     ScaleViewYdenom = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_SCALEWINDOW:
                     bScaleWindowExt = TRUE;
                     sprintf (szXValue, "Enter Numerators (x,y)");
                     sprintf (szYValue, "ScaleWindowExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     ScaleWindowXnum = atoi (szXValue);
                     ScaleWindowYnum = atoi (szYValue);

                     sprintf (szXValue, "Enter Denominators (x,y)");
                     sprintf (szYValue, "ScaleWindowExt");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     ScaleWindowXdenom = atoi (szXValue);
                     ScaleWindowYdenom = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_GETVIEWPORTEXT:
                     hDC = GetDC (hWnd);
                     SetMapMode (hDC, MM_ANISOTROPIC);
                     if (bSetViewportExt)
                         SetViewportExt    (hDC, SetViewX, SetViewY);
                     Check = GetViewportExt (hDC);
                     sprintf (szOutputBuffer1, "Viewport Extension = (%i,%i)",
                             LOWORD (Check), HIWORD (Check));
                     MessageBox (hWnd, szOutputBuffer1, "GetViewportExt", MB_O
                     ReleaseDC (hWnd, hDC);
                     break;

                case IDM_GETWINDOWEXT:
                     hDC = GetDC (hWnd);
                     SetMapMode (hDC, MM_ANISOTROPIC);
                     if (bSetWindowExt)
                         SetWindowExt      (hDC, SetWindowX, SetWindowY);
                     Check = GetWindowExt (hDC);
                     sprintf (szOutputBuffer1, "Window Extention = (%i,%i)",
                             LOWORD (Check), HIWORD (Check));
                     MessageBox (hWnd, szOutputBuffer1, "GetWindowExt", MB_OK)
                     ReleaseDC (hWnd, hDC);
                     break;

                case IDM_SETVIEWPORTORG:
                     bSetViewportOrg = TRUE;
                     sprintf (szXValue, "Enter Origin (x,y)");
                     sprintf (szYValue, "SetViewportOrg");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     SetViewportOrgX = atoi (szXValue);
                     SetViewportOrgY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_SETWINDOWORG:
                     bSetWindowOrg = TRUE;
                     sprintf (szXValue, "Enter Origin (x,y)");
                     sprintf (szYValue, "SetWindowOrg");
                     DialogBox (hInstMain, (LPSTR)"EnterPointDlg", hWnd,
                            lpProcEnterPoint);
                     SetWindowOrgX = atoi (szXValue);
                     SetWindowOrgY = atoi (szYValue);

                     InvalidateRect (hWnd, NULL, TRUE);
                     UpdateWindow (hWnd);
                     break;

                case IDM_HELP:
                     ProcessMessage (hWnd, 2);
                     break;
             }
             break;

       case WM_PAINT:
             hDC=BeginPaint(hWnd, &ps);
             SetMapMode (hDC, MM_ANISOTROPIC);
             SetViewportOrg (hDC, xClient/2, yClient/2);

             if (bOffsetViewportOrg)
                   OffsetViewportOrg (hDC, OffViewX, OffViewY);
             if (bOffsetWindowOrg)
                   OffsetWindowOrg   (hDC, OffWindowX, OffWindowY);
             if (bSetViewportExt)
                   SetViewportExt    (hDC, SetViewX, SetViewY);
             if (bSetWindowExt)
                   SetWindowExt      (hDC, SetWindowX, SetWindowY);
             if (bScaleViewportExt)
                   ScaleViewportExt  (hDC, ScaleViewXnum, ScaleViewXdenom,
                                      ScaleViewYnum, ScaleViewYdenom);
             if (bScaleWindowExt)
                   ScaleWindowExt  (hDC, ScaleWindowXnum, ScaleWindowXdenom,
                                      ScaleWindowYnum, ScaleWindowYdenom);
             if (bSetViewportOrg)
                   SetViewportOrg (hDC, SetViewportOrgX, SetViewportOrgY);
             if (bSetWindowOrg)
                   SetWindowOrg (hDC, SetWindowOrgX, SetWindowOrgY);

             MoveTo (hDC, 0, 0);
             ShowCursor (TRUE);
             for (fRadius=(float)0; fRadius<fMaxRadius; fRadius+=fRadiusInc) {
                  xXcoord = fRadius * cos(fAngle);
                  yYcoord = fRadius * sin(fAngle) * fProportion;
                  LineTo (hDC, (short)xXcoord, (short)yYcoord);
                  fAngle +=fAngleShift;
             }
             EndPaint (hWnd, &ps);
             break;

        case WM_DESTROY:
             PostQuitMessage (0);
             break;

       default:
             return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
   return 0L;
 }

 /***************************************************************************/

 BOOL FAR PASCAL GetRadiusDlgProc (hDlg, iMessage, wParam, lParam)
 HWND hDlg;
 unsigned iMessage;
 WORD wParam;
 LONG lParam;
 {
      int Index;
      char szChange [10];
      long lReturn;

      switch (iMessage) {
         case WM_INITDIALOG:
              SendDlgItemMessage (hDlg, IDD_RADIUS, EM_LIMITTEXT,
                                  (WORD)80, 0L);
              SetDlgItemText (hDlg, IDD_RADIUS, "1.0");
              return TRUE;
              break;

         case WM_COMMAND:
              switch (wParam)
              {
                case IDD_RADIUS:
                     if (HIWORD (lParam) == EN_CHANGE)
                         EnableWindow (GetDlgItem(hDlg,IDOK),
                                      (BOOL)SendMessage(LOWORD (lParam),
                                       WM_GETTEXTLENGTH, 0, 0L)) ;
                     break;

                case IDOK:
                     GetDlgItemText (hDlg, IDD_RADIUS, szRadius, 80) ;
                     OemToAnsi (szRadius, szRadius);
                     EndDialog (hDlg, TRUE);
                     break;

                case IDCANCEL:
                 EndDialog (hDlg, FALSE) ;
                     break;

                default:
                     return FALSE;
              }
         default:
              return FALSE;
      }
      return TRUE;
 }

 /****************************************************************************

 BOOL FAR PASCAL EnterPointDlgProc (hDlg, iMessage, wParam, lParam)
 HWND hDlg;
 unsigned iMessage;
 WORD wParam;
 LONG lParam;
 {
      int Index;
      char szChange [10];
      long lReturn;

      switch (iMessage) {
      case WM_INITDIALOG:
        SendDlgItemMessage (hDlg, IDD_X, EM_LIMITTEXT,
                            (WORD)40, 0L);
        SendDlgItemMessage (hDlg, IDD_Y, EM_LIMITTEXT,
                            (WORD)40, 0L);
        SetDlgItemText (hDlg, IDD_TEXT1, szXValue);
        SetDlgItemText (hDlg, IDD_TEXT2, szYValue);

        hX = GetDlgItem (hDlg, IDD_X);
          lpProcOldX = (FARPROC) GetWindowLong (hX, GWL_WNDPROC);
          SetWindowLong (hX, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hX, EM_SETSEL, 0, MAKELONG (0,32767));
        hY = GetDlgItem (hDlg, IDD_Y);
          lpProcOldY = (FARPROC) GetWindowLong (hY, GWL_WNDPROC);
          SetWindowLong (hY, GWL_WNDPROC, (LONG) lpProcNewEnterPoint);
          SendMessage (hY, EM_SETSEL, 0, MAKELONG (0,32767));
        hOK2 = GetDlgItem (hDlg, IDOK);

        return TRUE;
        break;

      case WM_COMMAND:
        switch (wParam) {
          case IDD_X:
               break;

          case IDD_Y:
               break;

          case IDOK:
               GetDlgItemText (hDlg, IDD_X, szXValue, 10) ;
               GetDlgItemText (hDlg, IDD_Y, szYValue, 10) ;
               EndDialog (hDlg, TRUE);
               break;

          default:
               return FALSE;
       }
     default:
       return FALSE;
   }
   return TRUE;
 }

 /****************************************************************************

 BOOL FAR PASCAL NewEnterPointDlgProc  (hWnd, iMessage, wParam, lParam)
      HWND     hWnd;
      unsigned iMessage;
      WORD     wParam;
      LONG     lParam;
 {
      switch (iMessage) {
        case WM_GETDLGCODE:
             return (DLGC_WANTALLKEYS);

        case WM_CHAR:
             if ((wParam == VK_TAB) || (wParam == VK_RETURN)) {
                 SendMessage (hWndMain, WM_USER, 0, 0L);
                 SetFocus (FindNextWindow (hWnd));
                 return TRUE;
             }
             else {
               if (hWnd == hX)
                 return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                         iMessage, wParam, lParam));
               if (hWnd == hY)
                 return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                         iMessage, wParam, lParam));
             }
             break;

        default:
          if (hWnd == hX)
             return ((BOOL)CallWindowProc (lpProcOldX, hWnd,
                     iMessage, wParam, lParam));
          if (hWnd == hY)
             return ((BOOL)CallWindowProc (lpProcOldY, hWnd,
                     iMessage, wParam, lParam));
      }
 }

 /****************************************************************************

 HWND FindNextWindow (hWnd)
      HWND   hWnd;
 {
      if (hWnd == hX)      return hY;
      if (hWnd == hY)      return hOK2;
      return NULL;
 }



 WAITMSG.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MESSAGE\WAITMSG.C

 /*

 Function(s) demonstrated in this program: WaitMessage

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  This function yields control to other applications when an
     application has no other tasks to perform.  The WaitMessage function
    suspends the application and does not return until a new message is
    placed in the application's queue.

 Additional Comments:

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "WaitMsg.h"


 HWND     hWndMain;
 HANDLE   hInstMain;

 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use  of  the  WaitMessage Windows function.",

 "Help Message",
 "     This program uses the WaitMessage Windows\n\
 function to suspend processing of the current\n\
 Window function until the window receives another\n\
 Message.  To test this function type a character\n\
 making sure not to move the cursor.  At this\n\
 point the Window will be suspended until you give\n\
 it another message.  This can be done by simply\n\
 moving the cursor.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "WaitMsg" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;
           }

      hWndMain = CreateWindow (szAppName,        /* window class name       */
                     "WaitMessage",              /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

      ShowWindow (hWndMain, nCmdShow) ;
      UpdateWindow (hWndMain) ;

      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  PAINTSTRUCT ps;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_KEYUP:
        WaitMessage ();
        MessageBox (hWnd, "Window returned to regular processing",
                    "WaitMessage",MB_OK);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {
           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }




 WFPOINT.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\WFPOINT.C

 /*
  *  Function(s) demonstrated in this program: WindowFromPoint
  *  Compiler version: 5.1
  *  Description:
  *     This program will get the handle to the window that contains the
  *  point ( 100, 100 ) in it.
  */

 #include <windows.h>

 long FAR PASCAL WndProc(HWND, unsigned, WORD, LONG);

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE      hInstance, hPrevInstance ;
 LPSTR       lpszCmdLine ;
 int         nCmdShow ;
   {
   HWND        hWnd;          /*  Handle to the window to iconize  */
   POINT       pPoint;        /*  Will hold the point  */

   pPoint.x = 100;            /*  Set the point to 100, 100  */
   pPoint.y = 100;

   hWnd = WindowFromPoint( pPoint );  /*  Get the window handle  */

   MessageBox( GetFocus(), (LPSTR)"We have the handle to the window",
               (LPSTR)"", MB_OK );
   return( TRUE );
   }


 WINFIND.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\WINFIND.C

 #include <windows.h>

 void FAR PASCAL locate();


 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    cmdShow;
 {
     locate();
     return 0;
 }

 void FAR PASCAL locate()
 {
   char   buf[60];

   GetModuleFileName( GetModuleHandle((LPSTR)"winfind"), buf, 60 );
   MessageBox( GetFocus(), (LPSTR)buf, (LPSTR)"module loaded from", MB_OK);

 }



 WINSPAWN.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\WINSPAWN.C

 /*

 Function(s) demonstrated in this program: Int21Function4B, LockSegment,
    UnlockSegment

 Windows version:  2.03

 Windows SDK version:  2.00

 Compiler version:  C 5.10

 Description:  Int21Function4B is a Function created using Masm, and it
    corresponds with the MS-DOS interrupt 21 function 4BH.  The function
    LockSegment locks the segment whose segment address is specified
   by the parameter.  If the parameter is -1 the function locks the
    current data segment.  The function UnlockSegment unlocks the segment
    whose address is specified by the parameter, -1 indicates current
   segment.

 Additional Comments:  Int21Function4B can be used to spawn windows
    applications, as well as old MS-DOS applications from within a
    windows application.  A method of sending command line arguments
    to the spawnded windows application is also discussed.

 */

 #define NOMINMAX
 #include <windows.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "WinSpawn.h"

 HWND     hWndMain;
 HANDLE   hInstMain;
 char     szOutputBuffer1 [70];
 char     szOutputBuffer2 [500];
 char     szSpawnAppName  [40];
 char     szCommandLine   [40];

 typedef struct {WORD   environment;
                 LPSTR  commandline;
                 LPSTR  FCB1;
                 LPSTR  FCB2;
                } EXECBLOCK;
 EXECBLOCK      exec;
 WORD           w[2];


 /****************************************************************************
 /************************    Message Structure      *************************
 /****************************************************************************

 struct { char *szMessage; }
        Messages [] = {
 "About",
 "     This is a sample application to demonstrate the\n\
 use of the LockSegment and UnlockSegment Windows\n\
 Functions, as well as Interrupt 21 function 4B in\n\
 spawning Windows applications, and MS-DOS applications\n\
 from a Windows Windows application.",

 "Help Message",
 "     This program demonstrates the use of the\n\
 Windows Function LockSegment, UnlockSegment, and\n\
 Int21Function4B.  Use the menu to select either a\n\
 MS-DOS application or a Windows application to be\n\
 spawned.  The program will also send command line\n\
 arguments to the spawned application.",

 "LockSegment",
 "    The current data segment has been locked.",

 "UnlockSegment",
 "    The current data segment has been unlocked.",

 };

 /****************************************************************************

 void ProcessMessage (HWND, int);

 void ProcessMessage (hWnd, MessageNumber)
      HWND     hWnd;
      int      MessageNumber;
 {
      sprintf (szOutputBuffer1, "%s", Messages [MessageNumber]);
      sprintf (szOutputBuffer2, "%s", Messages [MessageNumber + 1]);
      MessageBox (hWnd, szOutputBuffer2, szOutputBuffer1, MB_OK);
 }

 /****************************************************************************

 int PASCAL WinMain (hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
      HANDLE      hInstance, hPrevInstance ;
      LPSTR       lpszCmdLine ;
      int         nCmdShow ;
      {
      static char szAppName [] = "WinSpawn" ;
      static char szChildClass [] = "WinSpawnChild" ;
      HWND        hWnd ;
      WNDCLASS    wndclass ;
      MSG msg;

      if (!hPrevInstance)
           {
           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
           wndclass.lpfnWndProc   = WndProc ;
           wndclass.cbClsExtra    = 0 ;
           wndclass.cbWndExtra    = 0 ;
           wndclass.hInstance     = hInstance ;
           wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
           wndclass.lpszMenuName  = szAppName ;
           wndclass.lpszClassName = szAppName ;

           if (!RegisterClass (&wndclass))
                return FALSE ;

           }

      hWnd = CreateWindow (szAppName,            /* window class name       */
                     "Windows Spawn",            /* window caption          */
                     WS_OVERLAPPEDWINDOW,        /* window style            */
                     CW_USEDEFAULT,              /* initial x position      */
                     0,                          /* initial y position      */
                     CW_USEDEFAULT,              /* initial x size          */
                     0,                          /* initial y size          */
                     NULL,                       /* parent window handle    */
                     NULL,                       /* window menu handle      */
                     hInstance,                  /* program instance handle */
                     NULL) ;                     /* create parameters       */

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

      hWndMain  = hWnd;
      hInstMain = hInstance;

      while (GetMessage(&msg, NULL, 0, 0))
      {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
      }
      return (msg.wParam) ;
      }

 /****************************************************************************

 long FAR PASCAL WndProc (hWnd, iMessage, wParam, lParam)
 HWND     hWnd ;
 unsigned iMessage ;
 WORD     wParam ;
 LONG     lParam ;
 {
  HMENU       hMenu;
  PAINTSTRUCT ps;

  switch(iMessage)
  {
   case WM_CREATE:
        hMenu = GetSystemMenu (hWnd, FALSE);

        ChangeMenu (hMenu, NULL, "&About", IDM_ABOUT,
                    MF_APPEND | MF_STRING);
        break;

   case WM_SYSCOMMAND:
        switch (wParam) {
           case IDM_ABOUT:
                ProcessMessage (hWnd, 0);
                break;
           default:
                return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
        }
        break;

   case WM_COMMAND:
        switch (wParam) {

           case IDM_SPAWNIT:
                GlobalCompact(-1L);
                LockSegment (-1);
                ProcessMessage (hWnd, 4);

                exec.environment = 0;
                exec.commandline = szCommandLine;

                w[0] = 2;
                w[1] = SW_SHOWNORMAL;
                exec.FCB1 = (LPSTR)w;
                exec.FCB2 = (LPSTR)NULL;

                Int21Function4B(0, (LPSTR)szSpawnAppName,
                                (LPSTR)&exec);

                UnlockSegment (-1);
                ProcessMessage (hWnd, 6);
                break;

           case IDM_CLOCK:
                sprintf (szSpawnAppName,"CLOCK.EXE");
                sprintf (szCommandLine, "\0\r");
                SendMessage (hWnd, WM_COMMAND, IDM_SPAWNIT, 0L);
                break;

           case IDM_DOSDIRSORT:
                sprintf (szSpawnAppName,"COMMAND.COM");
                sprintf (szCommandLine, "%c /c dir | sort\0\r", 14);
                SendMessage (hWnd, WM_COMMAND, IDM_SPAWNIT, 0L);
                break;

           case IDM_DOSTYPE:
                sprintf (szSpawnAppName,"COMMAND.COM");
                sprintf (szCommandLine, "%c /c type winspawn.c\0\r", 0x13);
                SendMessage (hWnd, WM_COMMAND, IDM_SPAWNIT, 0L);
                break;

           case IDM_NOTEPAD:
                sprintf (szSpawnAppName,"NOTEPAD.EXE");
                sprintf (szCommandLine, " WINSPAWN.C\0\r");
                SendMessage (hWnd, WM_COMMAND, IDM_SPAWNIT, 0L);
                break;


           case IDM_HELP:
                ProcessMessage (hWnd, 2);
                break;
        }
        break;

   case WM_PAINT:
        BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
        EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
        break;

   case WM_DESTROY:
        PostQuitMessage(0);
        break;

   default:
   {
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
   }
  }
  return (0L);
 }


 WNDPROC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\MENUHELP\WNDPROC.C

 #include "windows.h"
 #include "APP.h"
 #include "stdlib.h"
 #include "string.h"

 /* Static definitions */
 FARPROC lpprocHook;
 FARPROC lplpfnNextHook;

 /* Keep track of the application's window handle for hook processing */
 HWND hApp;

 /* Function proto-types */
 void FAR PASCAL InitHook( HWND );
 BOOL FAR PASCAL KillHook();
 DWORD FAR PASCAL Hook( int, WORD, LPMSG );

 extern HANDLE hInst;

 extern APPCommand( HWND, WORD, LONG );
 extern APPPaint  ( HWND, WORD, LONG );

 long FAR PASCAL WndProc( HWND, unsigned, WORD, LONG );
 BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );


 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpprocAbout;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             /* Bind callback function with module instance */
             lpprocAbout = MakeProcInstance( (FARPROC)About, hInst);
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             FreeProcInstance( (FARPROC)About );
             break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_COMMAND:
         switch (wParam) {
            case IDAPPMENU:
                 APPCommand( hWnd, wParam, lParam );
                 break;
            default:
                 return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_CREATE:
         InitHook( hWnd );
         break;

     case WM_DESTROY:
         KillHook();
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         APPPaint( hWnd, wParam, lParam );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }
 /*
 */


 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     if (message == WM_COMMAND) {
         EndDialog( hDlg, TRUE );
         return TRUE;
         }
     else if (message == WM_INITDIALOG)
         return TRUE;
     else return FALSE;
 }
 /*
 */


 /* Set the HOOK */
 void FAR PASCAL InitHook( hWnd )
 HWND hWnd;
 {
         hApp = hWnd;

         lpprocHook = MakeProcInstance( (FARPROC)Hook, hInst);
         lplpfnNextHook = SetWindowsHook( WH_MSGFILTER, lpprocHook );

         return;
 }
 /*
 */

 /* Remove the HOOK */
 BOOL FAR PASCAL KillHook()
 {
         BOOL fSuccess;

         fSuccess = UnhookWindowsHook( WH_MSGFILTER, lpprocHook );
         FreeProcInstance( lpprocHook );

         return fSuccess;
 }
 /*
 */

 /* Hook function */
 DWORD FAR PASCAL Hook( nCode, wParam, lParam )
 int nCode;
 WORD wParam;
 LPMSG lParam;
 {
         HDC hDC;
         TEXTMETRIC tmFontInfo;
         RECT rRect;
         int TextHeight;
         WORD y;

         if ((nCode != MSGF_MENU) || (lParam->message != WM_MENUSELECT) ) {
             DefHookProc( nCode, wParam, lParam, (FARPROC FAR *)&lplpfnNextHoo
             return 0;
         }

         hDC = GetDC( hApp );
         GetTextMetrics( hDC, (LPTEXTMETRIC)&tmFontInfo );
         TextHeight = tmFontInfo.tmExternalLeading + tmFontInfo.tmHeight;
         GetClientRect( hApp, (LPRECT)&rRect );
         y = rRect.bottom - TextHeight;
         switch (lParam->wParam) {
            case SC_CLOSE:
               TextOut( hDC, 0, y, (LPSTR)"Close the application ", 22 );
               break;
            case SC_MAXIMIZE:
               TextOut( hDC, 0, y, (LPSTR)"Enlarge to full size  ", 22 );
               break;
            case SC_MINIMIZE:
               TextOut( hDC, 0, y, (LPSTR)"Reduce window to icon ", 22 );
               break;
            case SC_MOVE:
               TextOut( hDC, 0, y, (LPSTR)"Change window position", 22 );
               break;
            case SC_RESTORE:
               TextOut( hDC, 0, y, (LPSTR)"Restore to normal size", 22 );
               break;
            case SC_SIZE:
               TextOut( hDC, 0, y, (LPSTR)"Change window size    ", 22 );
               break;

            case IDAPPMENU:
               TextOut( hDC, 0, y, (LPSTR)"Item 1 highlighted    ", 22 );
               break;
            case IDAPPMENU+1:
               TextOut( hDC, 0, y, (LPSTR)"Item 2 highlighted    ", 22 );
               break;
            case IDAPPMENU+2:
               TextOut( hDC, 0, y, (LPSTR)"Item 3 highlighted    ", 22 );
               break;
            case IDHELP:
               TextOut( hDC, 0, y, (LPSTR)"HELP the poor user    ", 22 );
               break;
            case IDSABOUT:
               TextOut( hDC, 0, y, (LPSTR)"Program information   ", 22 );
               break;

            default:
               TextOut( hDC, 0, y, (LPSTR)"                      ", 22 );
               break;
         }
         ReleaseDC( hApp, hDC );
         DefHookProc( nCode, wParam, lParam, (FARPROC FAR *)&lplpfnNextHook );
         return 0;
 }


 WNDPROC.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\JOURNAL\WNDPROC.C

 #include "windows.h"
 #include "APP.h"

 extern HANDLE hInst;

 extern APPPaint  ( HWND, WORD, LONG );

 /* Function proto-types of Journal control functions in DLL */
 void FAR PASCAL StartRecord();
 void FAR PASCAL StopRecord();
 void FAR PASCAL StartPlay();
 void FAR PASCAL StopPlay();

 long FAR PASCAL WndProc( HWND, unsigned, WORD, LONG );
 BOOL FAR PASCAL About( HWND, unsigned, WORD, LONG );

 long FAR PASCAL WndProc( hWnd, message, wParam, lParam )
 HWND hWnd;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     FARPROC lpprocAbout;
     HMENU hMenu;

     switch (message)
     {
     case WM_SYSCOMMAND:
         switch (wParam)
         {
         case IDSABOUT:
             /* Bind callback function with module instance */
             lpprocAbout = MakeProcInstance( (FARPROC)About, hInst);
             DialogBox( hInst, MAKEINTRESOURCE(ABOUTBOX), hWnd, lpprocAbout );
             FreeProcInstance( (FARPROC)About );
             break;
         default:
             return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_COMMAND:
         switch (wParam) {
            case IDRECORDON:
                 MessageBox( hWnd, (LPSTR)"About to Record!", (LPSTR)"WARNING!
                 StartRecord();
                 break;
            case IDRECORDOFF:
                 StopRecord();
                 break;
            case IDPLAY:
                 MessageBox( hWnd, (LPSTR)"About to Play!", (LPSTR)"WARNING!",
                 StartPlay();
                 break;

            default:
                 return DefWindowProc( hWnd, message, wParam, lParam );
         }
         break;

     case WM_DESTROY:
         /* Just in case.  Make sure un-hooked before app dies */
         StopRecord();
         StopPlay();
         PostQuitMessage( 0 );
         break;

     case WM_PAINT:
         APPPaint( hWnd, wParam, lParam );
         break;

     default:
         return DefWindowProc( hWnd, message, wParam, lParam );
         break;
     }
     return(0L);
 }
 /*
 */


 BOOL FAR PASCAL About( hDlg, message, wParam, lParam )
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     if (message == WM_COMMAND) {
         EndDialog( hDlg, TRUE );
         return TRUE;
         }
     else if (message == WM_INITDIALOG)
         return TRUE;
     else return FALSE;
 }
 /*
 */


 WRPROFST.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\STRING\WRPROFST.C

 /*
  * This program demonstrates the use of WriteProfileString(). In this
  * example, the string "fubar=yes" keyword and value is written to an
  * application name called "foo".  If this construct currently exists
  * in the win.ini file, it is reported to the user. Note! This program
  * makes permanent changes to the WIN.INI file, but should not affect
  * any existing applications.
  */

 #include <windows.h>

 #define CHARLEN  4

 int PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow)
 HANDLE hInstance, hPrevInstance;
 LPSTR  lpszCmdLine;
 int    nCmdShow;
 {
    char  szFooStr[5];
    int   iCopied;
    int   iResult;
    BOOL  bResult;

    iCopied = GetProfileString((LPSTR)"foo", (LPSTR)"fubar", (LPSTR)"ERR",
                               (LPSTR)szFooStr, CHARLEN);

    if (iCopied == NULL)
       MessageBox(GetFocus(), (LPSTR)"Error in Checking WIN.INI",
                  (LPSTR)"GetProfileString()", MB_OK);
    else if ((szFooStr[0] == 'y') &&
             (szFooStr[1] == 'e') &&
             (szFooStr[2] == 's'))
       MessageBox(GetFocus(), (LPSTR)"Profile String Currently Exists!",
                  (LPSTR)"GetProfileString()", MB_OK);

    else {
       MessageBox(GetFocus(),
                  (LPSTR)"Inserting 'fubar=yes' into [foo] section of WIN.INI.
                  (LPSTR)"WriteProfileString()", MB_OK);
       iResult = MessageBox(GetFocus(),
                            (LPSTR)"Continuing Will Change WIN.INI Contents!",
                            (LPSTR)"WriteProfileString()",
                            MB_OKCANCEL | MB_ICONEXCLAMATION);
       if (iResult != IDCANCEL) {
          bResult = WriteProfileString((LPSTR)"foo", (LPSTR)"fubar",
                                       (LPSTR)"yes");
          if (bResult == NULL)
             MessageBox(GetFocus(), (LPSTR)"Error In Writing To WIN.INI!",
                        (LPSTR)"WriteProfileString() Error!",
                        MB_OK | MB_ICONEXCLAMATION);
          }
       }

    return(0);
 }


 WRTCOMM.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\COMM\WRTCOMM.C

 /*
  *  WriteComm
  *
  *  This program demonstrates the use of the function WriteComm.
  *  It attempts to write a specified number of characters to the
  *  communication device that has already been opened. Before
  *  attempting to do any write, the communication device must have
  *  its device control block set up properly to a correct configuration.
  */

 #include "windows.h"

 /* Procedure called when the application is loaded for the first time */
 BOOL WinInit( hInstance )
 HANDLE hInstance;
 {
     WNDCLASS   wcClass;

     /* registering the parent window class */
     wcClass.hCursor        = LoadCursor( NULL, IDC_ARROW );
     wcClass.hIcon          = LoadIcon (hInstance, (LPSTR)"WindowIcon");
     wcClass.lpszMenuName   = (LPSTR)NULL;
     wcClass.lpszClassName  = (LPSTR)"Wrtcomm";
     wcClass.hbrBackground  = (HBRUSH)GetStockObject( WHITE_BRUSH );
     wcClass.hInstance      = hInstance;
     wcClass.style          = CS_HREDRAW | CS_VREDRAW;
     wcClass.lpfnWndProc    = DefWindowProc;
     wcClass.cbClsExtra     = 0;
     wcClass.cbWndExtra     = 0;

     RegisterClass( (LPWNDCLASS)&wcClass );
     return TRUE;        /* Initialization succeeded */
 }

 int PASCAL WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )
 HANDLE hInstance, hPrevInstance;
 LPSTR lpszCmdLine;
 int cmdShow;
 {
     HWND  hWnd;            /* Handle to the parent window             */
     short nCid;            /* Short integer identifying the opened
                             * communication device                    */
     short nBytes;          /* The number of characters written        */
     DCB   dcb;             /* The device control block                */

     WinInit( hInstance );

     hWnd = CreateWindow((LPSTR)"Wrtcomm",
                         (LPSTR)"Writing to Communication Devices",
                         WS_OVERLAPPEDWINDOW,
                         50,                /* x         */
                         50,                /* y         */
                         600,               /* width     */
                         250,               /* height    */
                         (HWND)NULL,        /* no parent */
                         (HMENU)NULL,       /* use class menu */
                         (HANDLE)hInstance, /* handle to window instance */
                         (LPSTR)NULL        /* no params to pass on */
                         );

     /* Make window visible according to the way the app is activated */
     ShowWindow( hWnd, cmdShow );
     UpdateWindow( hWnd );

     /* attempt to open the com1 port */
     nCid = OpenComm ((LPSTR)"COM1", 25, 25);
     if (nCid < 0)
       {
         MessageBox (hWnd, (LPSTR)"Com port not opened!!",(LPSTR)NULL,MB_OK);
         return 0;
       }

     /* the communication device control block must be set to the appropriate
      * settings of the other dumb terminal in order to read and write
      * properly
      */
     if (GetCommState (nCid, (DCB FAR *) &dcb) >= 0)
       { dcb.BaudRate = 9600;
         dcb.ByteSize = 8;
         dcb.StopBits = ONESTOPBIT;
         dcb.Parity   = NOPARITY;
         dcb.fRtsflow = FALSE;
         dcb.fDtrflow = FALSE;
         dcb.fOutX    = FALSE;
         dcb.fInX     = FALSE;
         dcb.fNull    = FALSE;
         dcb.XonLim   = 1;
         dcb.XoffLim  = 20;
       }

     SetCommState ((DCB FAR *) &dcb);

     nBytes = WriteComm (nCid, (LPSTR)"Writing to COM port #1", 22);
     if (nBytes > 0)
       MessageBox (hWnd, (LPSTR)"Written successfully", (LPSTR)"OK", MB_OK);
     else
       /* Error should be checked by calling GetCommError at this point
        * so that other communiation function will work properly
        */
       MessageBox (hWnd, (LPSTR)"Error Occurred", (LPSTR)"ERROR", MB_OK);

     /* must close the communication device before leaving the program */
     CloseComm (nCid);

     return 0;
 }




 YIELD.C
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\YIELD.C

 /*
  *  Yield
  *  yield.c
  *
  *  This program demonstrates the use of the function Yield.
  *  It does this by simply creating a message box that tells the user that
  *  the application is going to yield control to other applications.  After
  *  the user hits the OK button, the Yield call is made.
  *
  */

  "windows.h"      /* required for all Windows applications */
  "yield.h"        /* specific to this program              */

 HANDLE hInst;             /* current instance                      */

 int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
 HANDLE hInstance;         /* current instance             */
 HANDLE hPrevInstance;     /* previous instance            */
 LPSTR lpCmdLine;          /* command line                 */
 int nCmdShow;             /* show-window type (open/icon) */
 {
     HWND hWnd;            /* window handle       */
     MSG msg;              /* message             */
     HANDLE hMenu;         /* Handle to the menu  */

     if (!hPrevInstance)              /* Has application been initialized? */
         if (!YieldInit(hInstance))
             return (NULL);           /* Exits if unable to initialize     */

     hInst = hInstance;               /* Saves the current instance        */

     hMenu = LoadMenu( hInst, (LPSTR)"YieldMenu" );
                                      /*  Load the menu    */

     hWnd = CreateWindow("Yield",     /* window class      */
         "Yield Sample Application",  /* window name       */
         WS_OVERLAPPEDWINDOW,         /* window style      */
         CW_USEDEFAULT,               /* x position        */
         CW_USEDEFAULT,               /* y position        */
         CW_USEDEFAULT,               /* width             */
         CW_USEDEFAULT,               /* height            */
         NULL,                        /* parent handle     */
         hMenu,                       /* menu or child ID  */
         hInstance,                   /* instance          */
         NULL);                       /* additional info   */

     if (!hWnd)                       /* Was the window created? */
         return (NULL);

     ShowWindow(hWnd, nCmdShow);      /* Shows the window        */
     UpdateWindow(hWnd);              /* Sends WM_PAINT message  */

     while (GetMessage(&msg,     /* message structure                      */
             NULL,               /* handle of window receiving the message */
             NULL,               /* lowest message to examine              */
             NULL))              /* highest message to examine             */
         {
         TranslateMessage(&msg);  /* Translates virtual key codes           */
         DispatchMessage(&msg);   /* Dispatches message to window           */
     }
     return (msg.wParam);         /* Returns the value from PostQuitMessage */
 }

 BOOL YieldInit(hInstance)
 HANDLE hInstance;                /* current instance           */
 {
     HANDLE hMemory;              /* handle to allocated memory */
     PWNDCLASS pWndClass;         /* structure pointer          */
     BOOL bSuccess;               /* RegisterClass() result     */

     hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS));
     pWndClass = (PWNDCLASS) LocalLock(hMemory);

     pWndClass->style = NULL;
     pWndClass->lpfnWndProc = YieldWndProc;
     pWndClass->hInstance = hInstance;
     pWndClass->hIcon = LoadIcon(NULL, IDI_APPLICATION);
     pWndClass->hCursor = LoadCursor(NULL, IDC_ARROW);
     pWndClass->hbrBackground = GetStockObject(WHITE_BRUSH);
     pWndClass->lpszMenuName = (LPSTR) "YieldMenu";
     pWndClass->lpszClassName = (LPSTR) "Yield";

     bSuccess = RegisterClass(pWndClass);

     LocalUnlock(hMemory);     /* Unlocks the memory    */
     LocalFree(hMemory);       /* Returns it to Windows */

     return (bSuccess);        /* Returns result of registering the window */
 }

 long FAR PASCAL YieldWndProc(hWnd, message, wParam, lParam)
 HWND hWnd;                    /* window handle                   */
 unsigned message;             /* type of message                 */
 WORD wParam;                  /* additional information          */
 LONG lParam;                  /* additional information          */
 {
     FARPROC lpProcAbout;      /* pointer to the "About" function */
     HMENU hMenu;              /* handle to the System menu       */

     switch (message) {
         case WM_SYSCOMMAND:   /* message: command from system menu */
             if (wParam == ID_ABOUT) {
                 lpProcAbout = MakeProcInstance(About, hInst);

                 DialogBox(hInst,         /* current instance         */
                     "AboutBox",          /* resource to use          */
                     hWnd,                /* parent handle            */
                     lpProcAbout);        /* About() instance address */

                 FreeProcInstance(lpProcAbout);
                 break;
             }

             else                         /* Lets Windows process it       */
                 return (DefWindowProc(hWnd, message, wParam, lParam));

         case WM_CREATE:                  /* message: window being created */

             /* Get the handle of the System menu */

             hMenu = GetSystemMenu(hWnd, FALSE);

             /* Add a separator to the menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 NULL,                            /* new menu item       */
                 NULL,                            /* menu identifier     */
                 MF_APPEND | MF_SEPARATOR);       /* type of change      */

             /* Add new menu item to the System menu */

             ChangeMenu(hMenu,                    /* menu handle         */
                 NULL,                            /* menu item to change */
                 "A&bout Yield...",               /* new menu item       */
                 ID_ABOUT,                        /* menu identifier     */
                 MF_APPEND | MF_STRING);          /* type of change      */
             break;

         case WM_COMMAND:
             if ( wParam == IDM_YIELD )
               {
               MessageBox(hWnd,(LPSTR)"Hit OK to Give Up Control of Processor"
                               (LPSTR)"Give It Up!",MB_OK);

                         /*  Tell User what we are going to do  */

               Yield();  /*  Do it!  -  This will cause Windows to see if
                          *  are currently any other applications that wish
                          *  to run.  If there are, then control will be
                          *  given to one of those applications.
                          */

               MessageBox(hWnd,(LPSTR)"We Have Control Back!",
                               (LPSTR)"Got it Back",MB_OK);
               }
             break;

 /*  Because of how quickly the whole process goes, the user will not be able
  *  notice the difference unless a very demanding application is present at
  *  the time the Yield box is selected from the menu.
  */
         case WM_DESTROY:             /* message: window being destroyed */
             PostQuitMessage(0);
             break;

         default:                     /* Passes it on if unproccessed    */
             return (DefWindowProc(hWnd, message, wParam, lParam));
     }
     return (NULL);
 }

 BOOL FAR PASCAL About(hDlg, message, wParam, lParam)
 HWND hDlg;
 unsigned message;
 WORD wParam;
 LONG lParam;
 {
     switch (message) {
         case WM_INITDIALOG:              /* message: initialize dialog box */
             return (TRUE);

         case WM_COMMAND:                 /* message: received a command */
             if (wParam == IDOK) {        /* "OK" box selected?          */
                 EndDialog(hDlg, NULL);   /* Exits the dialog box        */
                 return (TRUE);
             }
             break;
     }
     return (FALSE);                      /* Didn't process a message    */
 }




 Microsoft Windows Sample Source Code (MASM)


 FINDRESA.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\APPS\FINDRESA.ASM

         title   Hardware Dependent Parameters
         %out    config
         page    ,132
 OEM     segment public
 dw         0,     -7999
 dw         836,   -7956
 dw         1663,  -7825
 dw         2472,  -7608
 dw         3253,  -7308
 dw         3999,  -6928
 dw         4702,  -6472
 dw         5353,  -5945
 dw         5945,  -5353
 dw         6472,  -4702
 dw         6928,  -4000
 dw         7308,  -3253
 dw         7608,  -2472
 dw         7825,  -1663
 dw         7956,  -836

 dw         8000,  0
 dw         7956,  836
 dw         7825,  1663
 dw         7608,  2472
 dw         7308,  3253
 dw         6928,  4000
 dw         6472,  4702
 dw         5945,  5353
 dw         5353,  5945
 dw         4702,  6472
 dw         3999,  6928
 dw         3253,  7308
 dw         2472,  7608
 dw         1663,  7825
 dw         836,   7956

 dw          0,    7999
 dw         -836,  7956
 dw         -1663, 7825
 dw         -2472, 7608
 dw         -3253, 7308
 dw         -4000, 6928
 dw         -4702, 6472
 dw         -5353, 5945
 dw         -5945, 5353
 dw         -6472, 4702
 dw         -6928, 3999
 dw         -7308, 3253
 dw         -7608, 2472
 dw         -7825, 1663
 dw         -7956, 836

 dw         -7999, -0
 dw         -7956, -836
 dw         -7825, -1663
 dw         -7608, -2472
 dw         -7308, -3253
 dw         -6928, -4000
 dw         -6472, -4702
 dw         -5945, -5353
 dw         -5353, -5945
 dw         -4702, -6472
 dw         -3999, -6928
 dw         -3253, -7308
 dw         -2472, -7608
 dw         -1663, -7825
 dw         -836 , -7956
 OEM     ends
 end



 GETTIMER.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\TIME\GETTIMER.ASM

 ; get the time more efficiently than cmerge and DOSCALL() do

 include cmacros.inc

 time  struc
   hour  dw  ?
   minute  dw  ?
   second  dw  ?
 time  ends

 assumes CS,CODE
 assumes DS,DATA

 sBegin   CODE

 cProc  GetTime, <PUBLIC, NEAR>
   parmW  pTime        ; pointer to the structure to fill
 cBegin
   mov  ax, 2c00h      ; get time
   int  21h
   mov  bx, pTime
   cmp  ch, 12      ; if hour <12
   jl  lt12      ; we're ok
   sub  ch,12      ; else adjust it
 lt12:
   xor  ax,ax
   mov  al,ch
   mov  [bx].hour, ax
   mov  al,cl
   mov  [bx].minute, ax
   mov  al,dh
   mov  [bx].second, ax
 cEnd
 sEnd  CODE
   END


 LIBINIT.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\DDE\DDESPY\LIBINIT.ASM

 ?PLM = 1;
 ?WIN = 1;
 memS = 1

 include cmacros.inc

 externFP    <LocalInit>
 externFP    <UnlockSegment>

 ; PUBLIC definition of LIBINST, the library instance
 sBegin  DATA
         assumes DS,DATA
         PUBLIC  _LIBINST
 _LIBINST dw     ?
 sEnd    DATA

 sBegin CODE
 assumes CS,CODE

 cProc myastart,<PUBLIC,FAR>
 cBegin
         ;;
         ;; DS = automatic data segment.
         ;; CX = size of heap.
         ;; DI = module handle.
         ;; ES:SI = address of command line (not used).
         ;;

         mov    _LIBINST,di
         xor    ax,ax
         cCall  LocalInit,<ds,ax,cx>
         mov    ax,0ffffh
         cCall  UnlockSegment,<ax>
 cEND    myastart

 sEnd   CODE

 end myastart


 LIBINIT.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\HOOKS\JOURNAL\LIBINIT.ASM

 ?PLM = 1;
 ?WIN = 1;
 memS = 1

 include cmacros.inc

 externFP    <LocalInit>
 externFP    <UnlockSegment>

 ; PUBLIC definition of LIBINST, the library instance
 sBegin  DATA
         assumes DS,DATA
         PUBLIC  _LIBINST
 _LIBINST dw     ?
 sEnd    DATA

 sBegin CODE
 assumes CS,CODE

 cProc myastart,<PUBLIC,FAR>
 cBegin
         ;;
         ;; DS = automatic data segment.
         ;; CX = size of heap.
         ;; DI = module handle.
         ;; ES:SI = address of command line (not used).
         ;;

         mov    _LIBINST,di
         xor    ax,ax
         cCall  LocalInit,<ds,ax,cx>
         mov    ax,0ffffh
         cCall  UnlockSegment,<ax>
 cEND    myastart

 sEnd   CODE

 end myastart


 LIBINIT.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\LIBRARY\LIBINIT.ASM

 ?PLM = 1;
 ?WIN = 1;
 memS = 1

 include cmacros.inc

 externFP    <LocalInit>
 externFP    <UnlockSegment>

 ; PUBLIC definition of LIBINST, the library instance
 sBegin  DATA
         assumes DS,DATA
         PUBLIC  _LIBINST
 _LIBINST dw     ?
 sEnd    DATA

 sBegin CODE
 assumes CS,CODE

 cProc myastart,<PUBLIC,FAR>
 cBegin
         ;;
         ;; DS = automatic data segment.
         ;; CX = size of heap.
         ;; DI = module handle.
         ;; ES:SI = address of command line (not used).
         ;;

         mov    _LIBINST,di
         xor    ax,ax
         cCall  LocalInit,<ds,ax,cx>
         mov    ax,0ffffh
         cCall  UnlockSegment,<ax>
 cEND    myastart

 sEnd   CODE

 end myastart


 STACK.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\MEMORY\STACK\STACK.ASM

 ;
 ; WINDOWS STACK USAGE CHECKER
 ;
 ; This code checks for the amount of stack being used by a Windows applicatio
 ; It does this check by initializing the stack to a known value, then going
 ; from the end of stack up until it finds the first value changed.  If the
 ; first value checked is changed, then it assumes the stack overflowed.
 ;
 ; The way it finds the end of the stack is by the variable rsrvptrs[6].  This
 ; is initialized by the Windows initialization code.  Also, the start of the
 ; stack is rsrvptrs[A].  rsrvptrs[8] is the stack low-water mark, but this is
 ; only set if _chkstk is called, and Windows doesn't call this on its entry
 ; points (why, I don't know).
 ;
 ; The routine InitStackUsed() initializes the stack to a known value.  The
 ; routine ReportStackUsed() returns an integer value which is the amount of
 ; stack space used, -1 if stack overflow was detected.
 ;
 ; Written 10/87 by Bill Turner.  Original concept by Bill Turner (modified fr
 ; similar code for another environment)
 ;

 ;
 ; See what memory model to use for the stack checking routines.  This is
 ; specified when the module is assembled by specifying -D?S for small,
 ; -D?M for medium.
 ;

 if1
     ifdef ?S
         memS = 1
         %out ! Compiling for SWINLIBC.LIB
     else
         memM = 1
         %out ! Compiling for MWINLIBC.LIB/LWINLIBC.LIB
     endif
 endif

 ;
 ;   Now include the Windows macro definition file.
 ;

 .xlist
 ?PLM = 1;
 ?WIN = 1;
 include cmacros.inc
 .list

 sBegin  DATA
         externW rsrvptrs
 sEnd    DATA

 sBegin  CODE
 assumes CS,CODE
 assumes DS,DATA

         PUBLIC  InitStackUsed
         PUBLIC  ReportStackUsed

 ;
 ; void PASCAL InitStackUsed();
 ;
 ; This routine initializes the stack to a known value.  It uses the STOSW
 ; instruction, and therefore wipes ES, DI, AX, and CX.
 ;

 cProc   InitStackUsed
 cBegin

         push    ss
         pop     es
         mov     di, rsrvptrs[6]         ; minimum SP value
         mov     cx, sp
         sub     cx, di                  ; space from end of stack to current
                                         ; SP value (in bytes)
         shr     cx,1                    ; convert to word count
         mov     ax, 0AAAAh              ; "known value" for comparison
         cld                             ; move to high memory
         rep     stosw                   ; fill memory

 cEnd


 ;
 ; int PASCAL ReportStackUsed();
 ;
 ; This checks to see how much stack was actually used.  If the min SP value
 ; has been changed (ss:rsrvptrs[6]), then assume a stack overflow has occured
 ; Otherwise, scan through memory until a changed address is found, and subtra
 ; the address from the maximum SP value (rsrvptrs[A]).  This is the amount of
 ; stack space used.  This routine wipes out ES, DI, AX, and CX.
 ;

 cProc ReportStackUsed
 cBegin

         xor     cx, cx
         dec     cx              ; put -1 into CX -- so that REPZ will go unti
                                 ; an address that changed is found.
         push    ss
         pop     es
         mov     di, rsrvptrs[6]
         mov     ax, 0AAAAh      ; "known value" stack was initialized to
         cld                     ; move to high memory
         repz    scasw
 ;
 ; At this point, DI is the next word after the change was detected.  Decremen
 ; by one word, and calculate stack usage.
 ;
         cmp     di, rsrvptrs[6]         ; same as minimum value:
         jz      overflowed              ; YES, report overflow
         sub     di, rsrvptrs[0Ah]       ; difference in bytes (negative value
         mov     ax, di                  ; move into AX for return.
         neg     ax                      ; and make a positive number
         jmp     do_rtn

 overflowed:
         xor     ax, ax
         dec     ax                      ; move -1 into AX

 do_rtn:                                 ; dummy label for end of procedure

 cEnd

 sEnd    CODE

         end


 WSPAWN.ASM
 CD-ROM Disc Path:   \SAMPCODE\WIN_LRN\SPAWN\WSPAWN.ASM




 include cmacros.inc

 externFP   <GlobalCompact>

 createSeg   ASMCODE,ASMCODE,PARA,PUBLIC,ASMCODE

 ;;
 ;;  Int21Function4B cannot be a discardable segment.  If the segment
 ;;  were discardable, the int21 interrupt might cause it to be discarded
 ;;  and then reread from disk.  This would set stackSS and stackSP to 0.
 ;;  Upon return from int21, SS would be set to 0 and SP would be set to
 ;;  0.
 ;;
 ;;  Warning:  the code is not reentrant.  Multiple sp's cannot be saved.
 ;;  Warning:  In applications SS == DS by default.  If the DS should move
 ;;  the stored SS would be invalidated.  For maximum reliability it is
 ;;  recommended that LockData(), UnlockData() call bracket the call to
 ;;  int21function4B.
 ;;  Warning:  Should the code segment move using the debugging KERNEL,
 ;;  the segment will be checksummed and the write of SS:SP into the
 ;;  code segment detected as a fatal error.  To avoid this extraneous
 ;;  ( in this one instance ) error condition,
 ;;  use the non-debugging kernel or place the code in a fixed segment.
 ;;

 assumes CS,ASMCODE
 assumes DS,DATA


 sBegin DATA
 sEnd   DATA

 sBegin ASMCODE
   stackSS dw 0
   stackSP dw 0

 cProc   Int21Function4B,<PUBLIC,FAR>,<ax,bx,cx,dx,si,di,es,ds>
   parmB mode
   parmD path
   parmD execblock
 cBegin
       mov ax,-1
       cCall GlobalCompact,<ax,ax>
   mov cs:[stackSS],ss         ;; EXEC destroys all register. Save SS:SP.
   mov cs:[stackSP],sp
   mov al,mode
   lds dx,path
   les bx,execblock
   mov ah,4bh
   int 21h
   mov ss,cs:[stackSS]
   mov sp,cs:[stackSP]
 ; AX is return value
 cEnd

 sEnd ASMCODE
 END

