home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / win_lrn / dialog / diabox.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-11  |  10.2 KB  |  391 lines
  1.  
  2. #include <windows.h>
  3. #include <string.h>
  4. #include "diabox.h"
  5.  
  6. BOOL FAR PASCAL InitDiabox (HANDLE, HANDLE, int);
  7. LONG FAR PASCAL DiaboxWindowProc   (HANDLE, unsigned, WORD, LONG);
  8. BOOL FAR PASCAL DialogBoxWindowProc (HANDLE, unsigned, WORD, LONG); /* added */
  9. int     NEAR writeGMem (HANDLE, WORD, BYTE *, WORD);
  10.  
  11. HANDLE  hDTemplate;
  12. HANDLE  hInst;
  13. FARPROC lpDlgTest;
  14. HWND    hDlgTest;
  15. BOOL    nModeless;
  16. BOOL    bResult;
  17.  
  18. struct dtHdrType   {
  19.   LONG  dtStyle;
  20.   BYTE  dtItemCount;
  21.   int    dtX;
  22.   int    dtY;
  23.   int    dtCX;
  24.   int    dtCY;
  25.   char    dtResourceName[1];
  26.   char    dtClassName[1];
  27.   char    dtCaptionText[1];
  28.   };
  29.  
  30. #define DTHDR    struct dtHdrType
  31.  
  32. struct dtItmType   {
  33.   int    dtilX;
  34.   int    dtilY;
  35.   int    dtilCX;
  36.   int    dtilCY;
  37.   int    dtilID;
  38.   LONG  dtilWindowStyle;
  39.   BYTE  dtilControlClass;
  40.   char    dtilText[1];
  41.   };
  42.  
  43. #define DTITM    struct dtItmType
  44.  
  45. DTHDR    dtHdr;
  46. DTITM    dtItm;
  47. WORD     wByteCount;
  48. BYTE     work[256];
  49.  
  50. /*  Forward references and type checking */
  51.  
  52. BOOL DisplayDialogBox (HWND);
  53.  
  54. /**************************************************************************/
  55.  
  56. int     PASCAL WinMain  (hInstance, hPrevInstance, lpszCmdLine, cmdShow)
  57. HANDLE hInstance, hPrevInstance;
  58. LPSTR  lpszCmdLine;
  59. int    cmdShow;
  60.   {
  61.   MSG  msg;
  62.  
  63.   if (hPrevInstance)   /* do not allow more than one instance */
  64.     return FALSE;
  65.  
  66.   InitDiabox (hInstance, hPrevInstance, cmdShow);
  67.  
  68.   while (GetMessage ( (LPMSG) & msg, NULL, 0, 0))
  69.     {
  70.     if (nModeless == TRUE)
  71.       {
  72.       TranslateMessage ( (LPMSG) & msg);
  73.       DispatchMessage ( (LPMSG) & msg);
  74.       }
  75.     else 
  76.       {
  77.       if ( (hDlgTest == NULL) || !IsDialogMessage (hDlgTest, (LPMSG) & msg))
  78.         {
  79.         TranslateMessage ( (LPMSG) & msg);
  80.         DispatchMessage ( (LPMSG) & msg);
  81.         }
  82.       }
  83.     }
  84.   return (msg.wParam);
  85.   }
  86.  
  87. /*******************************   initialization   ***********************/
  88. BOOL FAR PASCAL InitDiabox (hInstance, hPrevInstance, cmdShow)
  89. HANDLE   hInstance;
  90. HANDLE   hPrevInstance;
  91. int      cmdShow;
  92.   {
  93.   WNDCLASS  wcDiaboxClass;
  94.   HWND      hWnd;
  95.  
  96.   wcDiaboxClass.lpszClassName = (LPSTR) "Diabox";
  97.   wcDiaboxClass.hInstance     = hInstance;
  98.   wcDiaboxClass.lpfnWndProc   = DiaboxWindowProc;
  99.   wcDiaboxClass.hCursor       = LoadCursor (NULL, IDC_ARROW);
  100.   wcDiaboxClass.hIcon         = NULL;
  101.   wcDiaboxClass.lpszMenuName  = (LPSTR) "diabox";             /* menu added  */
  102.   wcDiaboxClass.hbrBackground = GetStockObject (WHITE_BRUSH);
  103.   wcDiaboxClass.style         = CS_HREDRAW | CS_VREDRAW;
  104.   wcDiaboxClass.cbClsExtra    = 0;
  105.   wcDiaboxClass.cbWndExtra    = 0;
  106.  
  107.   RegisterClass ( (LPWNDCLASS) & wcDiaboxClass);
  108.   hWnd = CreateWindow ( (LPSTR) "Diabox",
  109.       (LPSTR) "DialogBox",
  110.       WS_OVERLAPPEDWINDOW,
  111.       CW_USEDEFAULT,
  112.       CW_USEDEFAULT,
  113.       CW_USEDEFAULT,
  114.       CW_USEDEFAULT,
  115.       (HWND)NULL,
  116.       (HMENU)NULL,
  117.       (HANDLE)hInstance,
  118.       (LPSTR)NULL
  119.      );
  120.  
  121.   hInst = hInstance;       /*  instance saved for dialog box  */
  122.  
  123.   ShowWindow   (hWnd, cmdShow);
  124.   UpdateWindow (hWnd);
  125.  
  126.   return TRUE;
  127.   }
  128.  
  129.  
  130. /*********************   window procedure - process messages   *************/
  131.  
  132. LONG FAR PASCAL DiaboxWindowProc (hWnd, message, wParam, lParam)
  133. HWND        hWnd;
  134. unsigned    message;
  135. WORD        wParam;
  136. LONG        lParam;
  137.   {
  138.   switch (message)
  139.     {
  140.     case WM_COMMAND:
  141.       switch (wParam)
  142.         {
  143.         case IDDBOX:
  144.           nModeless = FALSE;
  145.           bResult = DisplayDialogBox (hWnd);
  146.           break;
  147.  
  148.         case IDDBOX2:
  149.           nModeless = TRUE;
  150.           bResult = DisplayDialogBox (hWnd);
  151.           break;
  152.  
  153.         default:
  154.           return DefWindowProc (hWnd, message, wParam, lParam);
  155.           break;
  156.         }
  157.       break;
  158.  
  159.     case WM_DESTROY:
  160.       PostQuitMessage (0);
  161.       break;
  162.  
  163.     default:
  164.       return (DefWindowProc (hWnd, message, wParam, lParam));
  165.       break;
  166.     }
  167.   return (0L);
  168.   }
  169.  
  170.  
  171. /***************************************************************************/
  172. BOOL DisplayDialogBox (hWnd)
  173. HWND   hWnd;
  174.   {
  175.   LPSTR    lpDTemplate;
  176.  
  177.   if (hDlgTest != NULL)
  178.     return (FALSE);
  179.  
  180.   if (! (hDTemplate = GlobalAlloc (GMEM_MOVEABLE, (DWORD) sizeof (DTHDR))))
  181.     return (FALSE);
  182.  
  183.   wByteCount = 0;
  184.   dtHdr.dtStyle           = WS_POPUP | WS_VISIBLE | WS_BORDER | WS_CAPTION;
  185.   dtHdr.dtItemCount       = 4;
  186.   dtHdr.dtX               = 10;
  187.   dtHdr.dtY               = 10;
  188.   dtHdr.dtCX              = 200;
  189.   dtHdr.dtCY              = 100;
  190.   dtHdr.dtResourceName[0] = 0;
  191.   dtHdr.dtClassName[0]    = 0;
  192.  
  193.   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtHdr, sizeof (DTHDR) - 1))
  194.     return (FALSE);
  195.   wByteCount += sizeof (DTHDR) - 1;
  196.  
  197.   strcpy (work, "Template Test");
  198.   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
  199.     return (FALSE);
  200.   wByteCount += strlen (work) + 1;
  201.  
  202. /* add OK BUTTON item */
  203.  
  204.   dtItm.dtilX            = 30;
  205.   dtItm.dtilY            = 60;
  206.   dtItm.dtilCX           = 32;
  207.   dtItm.dtilCY           = 12;
  208.   dtItm.dtilID           = 0x0300;
  209.   dtItm.dtilWindowStyle  = BS_DEFPUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
  210.   dtItm.dtilControlClass = 0x80; /* BUTTON */
  211.   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) - 1))
  212.     return (FALSE);
  213.   wByteCount += sizeof (DTITM) - 1;
  214.  
  215.   strcpy (work, "OK");
  216.   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
  217.     return (FALSE);
  218.   wByteCount += strlen (work) + 1;
  219.  
  220.   work[0] = 0;
  221.   if (!writeGMem (hDTemplate, wByteCount, work, 1))
  222.     return (FALSE);
  223.   wByteCount += 1;
  224.  
  225. /* add CANCEL BUTTON item */
  226.  
  227.   dtItm.dtilX            = 70;
  228.   dtItm.dtilY            = 60;
  229.   dtItm.dtilCX           = 32;
  230.   dtItm.dtilCY           = 12;
  231.   dtItm.dtilID           = 0x0400;
  232.   dtItm.dtilWindowStyle  = BS_PUSHBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
  233.   dtItm.dtilControlClass = 0x80; /* BUTTON */
  234.   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) - 1))
  235.     return (FALSE);
  236.   wByteCount += sizeof (DTITM) - 1;
  237.  
  238.   strcpy (work, "Cancel");
  239.   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
  240.     return (FALSE);
  241.   wByteCount += strlen (work) + 1;
  242.  
  243.   work[0] = 0;
  244.   if (!writeGMem (hDTemplate, wByteCount, work, 1))
  245.     return (FALSE);
  246.   wByteCount += 1;
  247.  
  248. /* add EDIT item */
  249.  
  250.   dtItm.dtilX            = 30;
  251.   dtItm.dtilY            = 40;
  252.   dtItm.dtilCX           = 32;
  253.   dtItm.dtilCY           = 12;
  254.   dtItm.dtilID           = 0x0200;
  255.   dtItm.dtilWindowStyle  = ES_LEFT | WS_TABSTOP | WS_CHILD | WS_BORDER | WS_VISIBLE;
  256.   dtItm.dtilControlClass = 0x81; /* EDITCODE */
  257.   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) - 1))
  258.     return (FALSE);
  259.   wByteCount += sizeof (DTITM) - 1;
  260.  
  261.   strcpy (work, "Edit");
  262.   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
  263.     return (FALSE);
  264.   wByteCount += strlen (work) + 1;
  265.  
  266.   work[0] = 0;
  267.   if (!writeGMem (hDTemplate, wByteCount, work, 1))
  268.     return (FALSE);
  269.   wByteCount += 1;
  270.  
  271. /* add MESSAGE item */
  272.  
  273.   dtItm.dtilX     = 30;
  274.   dtItm.dtilY     = 20;
  275.   dtItm.dtilCX    = 100;
  276.   dtItm.dtilCY    = 8;
  277.   dtItm.dtilID    = 0x0100;
  278.   dtItm.dtilWindowStyle = SS_LEFT | WS_CHILD | WS_VISIBLE;
  279.   dtItm.dtilControlClass = 0x82; /* STATICCODE */
  280.   if (!writeGMem (hDTemplate, wByteCount, (BYTE *) & dtItm, sizeof (DTITM) - 1))
  281.     return (FALSE);
  282.   wByteCount += sizeof (DTITM) - 1;
  283.  
  284.   if (nModeless == FALSE)
  285.     strcpy (work, "Modal DialogBox");
  286.   else
  287.     strcpy (work, "Modeless DialogBox");
  288.  
  289.   if (!writeGMem (hDTemplate, wByteCount, work, strlen (work) + 1))
  290.     return (FALSE);
  291.   wByteCount += strlen (work) + 1;
  292.  
  293.   work[0] = 0;
  294.   if (!writeGMem (hDTemplate, wByteCount, work, 1))
  295.     return (FALSE);
  296.  
  297.   lpDlgTest = MakeProcInstance ( (FARPROC) DialogBoxWindowProc, hInst);
  298.  
  299.   if (nModeless == FALSE)
  300.     {
  301.     hDlgTest = DialogBoxIndirect (hInst, hDTemplate, hWnd, lpDlgTest);
  302.     FreeProcInstance ( (FARPROC) lpDlgTest);
  303.     hDlgTest = NULL;
  304.     }
  305.   else
  306.     {
  307.     lpDTemplate = GlobalLock (hDTemplate);
  308.     hDlgTest = CreateDialogIndirect (hInst, lpDTemplate, hWnd, lpDlgTest);
  309.     GlobalUnlock (hDTemplate);
  310.     }
  311.   return (TRUE);
  312.   }
  313.  
  314. /**************************************************************************/
  315. BOOL FAR PASCAL DialogBoxWindowProc (hDlg, message, wParam, lParam)
  316. HWND      hDlg;
  317. unsigned  message;
  318. WORD      wParam;
  319. LONG      lParam;
  320.   {
  321.   char    TempEdit[24];
  322.  
  323.   switch (message)
  324.     {
  325.     case WM_INITDIALOG:
  326.   /* SetFocus to first control that is not a static or group box */
  327.       SetFocus (GetDlgItem (hDlg, 0x0200));
  328.       break;
  329.  
  330.     case WM_COMMAND:
  331.       switch (wParam)
  332.         {
  333.         case 0x0100: /* static */
  334.         case 0x0200: /* edit   */
  335.           break;
  336.         case 0x0300: /* ok     */
  337.           GetDlgItemText (hDlg, 0x0200, TempEdit, 24);
  338.           MessageBox (GetFocus (), (LPSTR)TempEdit,
  339.                      (LPSTR)"Edit Control Contains", MB_OK);
  340.  
  341.           /*  No Break Here... We want to end the Dialog Box  */
  342.         case 0x0400: /* cancel */
  343.           if (nModeless == FALSE)
  344.             EndDialog (hDlg, TRUE);
  345.           else
  346.             {
  347.             DestroyWindow (hDlg);
  348.             hDlgTest = NULL;
  349.             }
  350.           return (TRUE);
  351.         default:
  352.           return (TRUE);
  353.         }           /* end wParam switch */
  354.       break;      /* end command */
  355.  
  356.     default:
  357.       return (FALSE);
  358.     }                 /* end message switch */
  359.   return (FALSE);
  360.   }
  361.  
  362. /****************************************************************************/
  363. int     NEAR writeGMem (hData, offset, data, length)
  364. HANDLE  hData;
  365. WORD    offset;
  366. BYTE    *data;
  367. WORD    length;
  368.   {
  369.   HANDLE  hNewData;
  370.   LPSTR   lpDstData;
  371.   int     n;
  372.  
  373.   if (offset + length > (WORD)GlobalSize (hData))
  374.     {
  375.     if (! (hNewData = GlobalReAlloc (hData, (DWORD) offset + length, GMEM_MOVEABLE)))
  376.       GlobalFree (hData);
  377.     hDTemplate = hNewData;
  378.     }
  379.  
  380.   if (lpDstData = GlobalLock (hData))
  381.     {
  382.     lpDstData = lpDstData + offset;
  383.     for (n = 0; n < length; n++)
  384.       *lpDstData++ = *data++;
  385.     GlobalUnlock (hData);
  386.     return (TRUE);
  387. /* return (lpDstData); */  /* return new offset position */
  388.     }
  389.   return (FALSE);
  390.   }
  391.