home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / gdipal.pak / GDIPAL.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  13KB  |  453 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993-1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE: gdipal.c
  9. //
  10. //  PURPOSE: Handles the main window for the GDIPal sample.
  11. //
  12. //  FUNCTIONS:
  13. //    WndProc            - Processes messages for the main window.
  14. //    MsgCommand         - Handle the WM_COMMAND messages for the main window.
  15. //    MsgCreate          - Handles the WM_CREATE message.  Creates the toolbar,
  16. //                         statusbar, and client windows.
  17. //    MsgSize            - Handles the WM_SIZE message by passing the message
  18. //                         on to the toolbar and statusbar controls and then
  19. //                         resizing the client window between them.
  20. //    MsgDestroy         - Handles the WM_DESTROY message by calling
  21. //                         PostQuitMessage().
  22. //    MsgPaletteChanged  - Passes WM_PALETTECHANGED message to
  23. //                         ProcessPaletteChanged
  24. //    MsgQueryNewPalette - Passes WM_QUERYNEWPALETTE message to
  25. //                         ProcessQueryNewPalette
  26. //    CmdRefresh         - Forces client window to repaint.
  27. //    CmdExit            - Handles the file exit command by calling destroy
  28. //                         window on the main window.
  29. //
  30. //  COMMENTS:
  31. //    Message dispatch table -
  32. //      For every message to be handled by the main window procedure
  33. //      place the message number and handler function pointer in
  34. //      rgmsd (the message dispatch table).  Place the prototype
  35. //      for the function in globals.h and the definition of the
  36. //      function in the appropriate module.
  37. //    Command dispatch table -
  38. //      For every command to be handled by the main window procedure
  39. //      place the command number and handler function pointer in
  40. //      rgcmd (the command dispatch table).  Place the prototype
  41. //      for the function in globals.h and the definition of the
  42. //      function in the appropriate module.
  43. //    Globals.h Contains the definitions of the structures and dispatch.c
  44. //      contains the functions that use these structures.
  45. //
  46.  
  47. #include <windows.h>            // required for all Windows applications
  48. #include <windowsx.h>
  49. #include <commctrl.h>           // prototypes and defs for common controls
  50. #include "globals.h"            // prototypes specific to this application
  51. #include "toolbar.h"            // prototypes for the tool bar
  52. #include "statbar.h"            // prototypes for the status bar
  53. #include "palette.h"            // prototypes for palette routines
  54.  
  55. // Global variables
  56. HWND hWndClient;
  57. HPALETTE  hPalette;             // App's logical palette
  58. BOOL      bPalDevice = FALSE;
  59.  
  60.  
  61. // Main window message table definition.
  62. MSD rgmsd[] =
  63. {
  64.     {WM_MENUSELECT,      MsgMenuSelect},
  65.     {WM_COMMAND,         MsgCommand},
  66.     {WM_NOTIFY,          MsgNotify},
  67.     {WM_TIMER,           MsgTimer},
  68.     {WM_SIZE,            MsgSize},
  69.     {WM_CREATE,          MsgCreate},
  70.     {WM_DESTROY,         MsgDestroy},
  71.  
  72.     // palette messages
  73.     {WM_PALETTECHANGED,  MsgPaletteChanged},
  74.     {WM_QUERYNEWPALETTE, MsgQueryNewPalette}
  75. };
  76.  
  77. MSDI msdiMain =
  78. {
  79.     sizeof(rgmsd) / sizeof(MSD),
  80.     rgmsd,
  81.     edwpWindow
  82. };
  83.  
  84.  
  85. // Main window command table definition.
  86. CMD rgcmd[] =
  87. {
  88.     {IDM_FILENEW,     CmdFileNew},
  89.     {IDM_EXIT,        CmdExit},
  90.  
  91.     {IDM_INFO,        CmdInfo},
  92.  
  93.     {IDM_PIXEL,       CmdDrawMode},
  94.     {IDM_LINE,        CmdDrawMode},
  95.     {IDM_RECT,        CmdDrawMode},
  96.     {IDM_ELLIPSE,     CmdDrawMode},
  97.     {IDM_BEZIER,      CmdDrawMode},
  98.     {IDM_FILL,        CmdFill},
  99.     {IDM_NOFILL,      CmdFill},
  100.     {IDM_CREATEPEN,   CmdCreatePen},
  101.     {IDM_CREATEBRUSH, CmdCreateBrush},
  102.     {IDM_REFRESH,     CmdRefresh},
  103.  
  104.     {IDM_ABOUT,       CmdAbout}
  105. };
  106.  
  107. CMDI cmdiMain =
  108. {
  109.     sizeof(rgcmd) / sizeof(CMD),
  110.     rgcmd,
  111.     edwpWindow
  112. };
  113.  
  114.  
  115. //
  116. //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
  117. //
  118. //  PURPOSE:  Processes messages for the main window.
  119. //
  120. //  PARAMETERS:
  121. //    hwnd     - window handle
  122. //    uMessage - message number
  123. //    wparam   - additional information (dependant on message number)
  124. //    lparam   - additional information (dependant on message number)
  125. //
  126. //  RETURN VALUE:
  127. //    The return value depends on the message number.  If the message
  128. //    is implemented in the message dispatch table, the return value is
  129. //    the value returned by the message handling function.  Otherwise,
  130. //    the return value is the value returned by the default window procedure.
  131. //
  132. //  COMMENTS:
  133. //    Call the DispMessage() function with the main window's message dispatch
  134. //    information (msdiMain) and the message specific information.
  135. //
  136.  
  137. LRESULT CALLBACK WndProc(HWND   hwnd,
  138.                          UINT   uMessage,
  139.                          WPARAM wparam,
  140.                          LPARAM lparam)
  141. {
  142.     return DispMessage(&msdiMain, hwnd, uMessage, wparam, lparam);
  143. }
  144.  
  145.  
  146. //
  147. //  FUNCTION: MsgCommand(HWND, UINT, WPARAM, LPARAM)
  148. //
  149. //  PURPOSE: Handle the WM_COMMAND messages for the main window.
  150. //
  151. //  PARAMETERS:
  152. //    hwnd     - window handle
  153. //    uMessage - WM_COMMAND (Unused)
  154. //    GET_WM_COMMAND_ID(wparam, lparam)   - Command identifier
  155. //    GET_WM_COMMAND_HWND(wparam, lparam) - Control handle
  156. //
  157. //  RETURN VALUE:
  158. //    The return value depends on the message number.  If the message
  159. //    is implemented in the message dispatch table, the return value is
  160. //    the value returned by the message handling function.  Otherwise,
  161. //    the return value is the value returned by the default window procedure.
  162. //
  163. //  COMMENTS:
  164. //    Call the DispCommand() function with the main window's command dispatch
  165. //    information (cmdiMain) and the command specific information.
  166. //
  167.  
  168. #pragma argsused
  169. LRESULT MsgCommand(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  170. {
  171.     return DispCommand(&cmdiMain, hwnd, wparam, lparam);
  172. }
  173.  
  174.  
  175. //
  176. //  FUNCTION: MsgCreate(HWND, UINT, WPARAM, LPARAM)
  177. //
  178. //  PURPOSE: Handle the WM_CREATE messages for the main window.
  179. //           and call InitCommonControls() API to initialize the
  180. //           common control library.
  181. //
  182. //  PARAMETERS:
  183. //    hwnd     - window handle
  184. //
  185. //  RETURN VALUE:
  186. //    Return TRUE if the StatusBar and ToolBar Windows could be created
  187. //    successfully.
  188. //
  189. //  COMMENTS:
  190. //    Call the CreateTSBars function with the main window's window handle
  191. //    information (msdiMain).
  192. //
  193.  
  194. #pragma argsused
  195. LRESULT MsgCreate(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  196. {
  197.     int nRet = -1;                              // Assume failure
  198.  
  199.     InitCommonControls();   // Initialize the common control library.
  200.  
  201.     // check palette capabilities
  202.  
  203.     bPalDevice = IsPaletteDevice();
  204.  
  205.     if (bPalDevice)
  206.     {
  207.         // create a default palette for choosing pen and brush colors
  208.         // using the new halftone palette
  209.         hPalette = CreateHalftonePalette(NULL);
  210.     }
  211.  
  212.     if(CreateTBar(hwnd) && CreateSBar(hwnd))    // 1st create tool/status bars
  213.     {
  214.           hWndClient = CreateClientWindow(hwnd);  // then create client window
  215.         if (hWndClient != NULL)
  216.             nRet = 0;                           // Indicate success
  217.     }
  218.  
  219.     // Initialize some menu options...
  220.  
  221.     CmdDrawMode(hwnd, IDM_LINE, 0, NULL);   // Set initial draw mode to Line
  222.  
  223.     CmdFill(hwnd, IDM_NOFILL, 0, NULL);     // Turn fill mode OFF
  224.     CmdFill(hwnd, IDM_FILL, 0, NULL);       // Toggle fill state (ON)
  225.  
  226.      return nRet;
  227. }
  228.  
  229.  
  230. //
  231. //  FUNCTION: MsgSize(HWND, UINT, WPARAM, LPARAM)
  232. //
  233. //  PURPOSE:  This function resizes the toolbar and statusbar controls
  234. //    and the Client window which covers the rest of the main window
  235. //    client area.
  236. //
  237. //
  238. //  PARAMETERS:
  239. //
  240. //    hwnd      - Window handle  (Used)
  241. //    uMessage  - Message number (Used)
  242. //    wparam    - Extra data     (Used)
  243. //    lparam    - Extra data     (Used)
  244. //
  245. //  RETURN VALUE:
  246. //
  247. //    Always returns 0 - Message handled
  248. //
  249. //  COMMENTS:
  250. //
  251. //    When the window procdure that has the status and tool bar controls
  252. //    receives the WM_SIZE message, it has to pass the message on to these
  253. //    controls so that these controls can adjust their size accordingly.
  254. //
  255. //
  256.  
  257. LRESULT MsgSize(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  258. {
  259.     SendMessage(hWndToolbar, uMessage, wparam, lparam);
  260.     SendMessage(hWndStatusbar, uMessage, wparam, lparam);
  261.  
  262.     // Re-position the panes in the status bar
  263.     InitializeStatusBar(hwnd);
  264.  
  265.     // Re-size client window relative to the tool/status bars
  266.  
  267.     if (wparam != SIZE_MINIMIZED)
  268.     {
  269.         RECT rc, rcClient;
  270.  
  271.         GetClientRect(hwnd, &rcClient);
  272.  
  273.         GetWindowRect(hWndToolbar, &rc);
  274.         ScreenToClient(hwnd, ((LPPOINT)&rc) + 1);
  275.         rcClient.top = rc.bottom;
  276.  
  277.         GetWindowRect(hWndStatusbar, &rc);
  278.         ScreenToClient(hwnd, (LPPOINT)&rc);
  279.         rcClient.bottom = rc.top;
  280.  
  281.         MoveWindow(hWndClient,
  282.                    rcClient.left,
  283.                    rcClient.top,
  284.                    rcClient.right-rcClient.left,
  285.                    rcClient.bottom-rcClient.top,
  286.                    FALSE);
  287.     }
  288.  
  289.     return 0;
  290. }
  291.  
  292.  
  293. //
  294. //  FUNCTION: MsgDestroy(HWND, UINT, WPARAM, LPARAM)
  295. //
  296. //  PURPOSE: Calls PostQuitMessage().
  297. //
  298. //  PARAMETERS:
  299. //
  300. //    hwnd      - Window handle  (Unused)
  301. //    uMessage  - Message number (Unused)
  302. //    wparam    - Extra data     (Unused)
  303. //    lparam    - Extra data     (Unused)
  304. //
  305. //  RETURN VALUE:
  306. //
  307. //    Always returns 0 - Message handled
  308. //
  309. //  COMMENTS:
  310. //
  311. //
  312.  
  313. #pragma argsused
  314. LRESULT MsgDestroy(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  315. {
  316.      PostQuitMessage(0);
  317.     return 0;
  318. }
  319.  
  320.  
  321. //
  322. //  FUNCTION: MsgPaletteChanged(HWND, UINT, WPARAM, LPARAM)
  323. //
  324. //  PURPOSE: Passes WM_PALETTECHANGED message to handler.
  325. //
  326. //  PARAMETERS:
  327. //    hwnd -     Handle of application window.
  328. //    uMessage - (unused)
  329. //    wparam -   Handle of window that caused palette to change
  330. //    lparam -   (unused)
  331. //
  332. //  RETURN VALUE:
  333. //    Returns the value returned by ProcessPaletteChanged.
  334. //
  335. //  COMMENTS:
  336. //
  337.  
  338. #pragma argsused
  339. LRESULT MsgPaletteChanged(HWND   hwnd,
  340.                                   UINT   uMessage,
  341.                                   WPARAM wparam,
  342.                                   LPARAM lparam)
  343. {
  344.     return ProcessPaletteChanged(hwnd, wparam); 
  345. }    
  346.  
  347.  
  348. //
  349. //  FUNCTION: MsgQueryNewPalette(HWND, UINT, WPARAM, LPARAM)
  350. //
  351. //  PURPOSE: Passes WM_QUERYNEWPALETTE message to handler.
  352. //
  353. //  PARAMETERS:
  354. //    hwnd     - Handle of application window.
  355. //    uMessage - (unused)
  356. //    wparam   - (unused)
  357. //    lparam   - (unused)
  358. //
  359. //  RETURN VALUE:
  360. //    Returns the value returned by ProcessQueryNewPalette.
  361. //
  362. //  COMMENTS:
  363. //
  364.  
  365. #pragma argsused
  366. LRESULT MsgQueryNewPalette(HWND   hwnd,
  367.                                     UINT   uMessage,
  368.                                     WPARAM wparam,
  369.                            LPARAM lparam)
  370. {
  371.     return ProcessQueryNewPalette(hwnd); 
  372. }
  373.  
  374.  
  375. //
  376. //  FUNCTION: CmdFileNew(HWND, WORD, WORD, HWND)
  377. //
  378. //  PURPOSE: Erases current drawing
  379. //
  380. //  PARAMETERS:
  381. //    hwnd     - The main window.
  382. //    wCommand - IDM_FILENEW (unused)
  383. //    wNotify  - Notification number (unused)
  384. //    hwndCtrl - NULL (unused)
  385. //
  386. //  RETURN VALUE:
  387. //    Always returns 0 - command handled.
  388. //
  389. //  COMMENTS:
  390. //
  391. //
  392.  
  393. #pragma argsused
  394. LRESULT CmdFileNew(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  395. {
  396.     // Tell client window to purge itself
  397.     ClientNewDrawing();
  398.     return 0;
  399. }
  400.  
  401.  
  402. //
  403. //  FUNCTION: CmdRefresh(HWND, WORD, WORD, HWND)
  404. //
  405. //  PURPOSE: Forces repaint of entire drawing.
  406. //
  407. //  PARAMETERS:
  408. //    hwnd     - The main window.
  409. //    wCommand - IDM_REFRESH (unused)
  410. //    wNotify  - Notification number (unused)
  411. //    hwndCtrl - NULL (unused)
  412. //
  413. //  RETURN VALUE:
  414. //    Always returns 0 - command handled.
  415. //
  416. //  COMMENTS:
  417. //
  418. //
  419.  
  420. #pragma argsused
  421. LRESULT CmdRefresh(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  422. {
  423.     // Force client to repaint.
  424.     InvalidateRect(hWndClient, NULL, TRUE);
  425.     return 0;
  426. }
  427.  
  428.  
  429. //
  430. //  FUNCTION: CmdExit(HWND, WORD, WORD, HWND)
  431. //
  432. //  PURPOSE: Exit the application.
  433. //
  434. //  PARAMETERS:
  435. //    hwnd     - The window.
  436. //    wCommand - IDM_EXIT (unused)
  437. //    wNotify  - Notification number (unused)
  438. //    hwndCtrl - NULL (unused)
  439. //
  440. //  RETURN VALUE:
  441. //    Always returns 0 - command handled.
  442. //
  443. //  COMMENTS:
  444. //
  445. //
  446.  
  447. #pragma argsused
  448. LRESULT CmdExit(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  449. {
  450.     DestroyWindow(hwnd);
  451.     return 0;
  452. }
  453.