home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / analog.pak / COPIER.C < prev    next >
Text File  |  1997-05-06  |  37KB  |  1,167 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:   copier.c
  9. //
  10. //  PURPOSE:   Displays a dialog box which demonstrates the use of several
  11. //    common controls, such as Progress Bar(Gas Gauge), Up/Down controls,
  12. //    slider control and Status Bar control.
  13. //
  14. //  FUNCTIONS:
  15. //    CopierProc - Processes messages for the Copier dialog box.
  16. //
  17. //    Copier Dialog Messages:
  18. //       MsgDlgInit - Processing  of WM_INITDIALOG for the Copier dialog box.
  19. //       MsgDlgCommand - Process WM_COMMAND message sent to Copier dialog box.
  20. //       MsgDlgHScroll - Processing of WM_HSCROLL for the Copier dialog box.
  21. //       MsgDlgTimer - Processing of WM_TIMER which is set by CmdStart()
  22. //
  23. //    Copier's WM_COMMAND Messages:
  24. //       CmdnCopies - Validates amount entered in number of copies edit contorl
  25. //       CmdStart - Starts the copy process.
  26. //       CmdReset - Resets the dialog with its default values.
  27. //       CmdStop - Stops/interupts the copy process.
  28. //       CmdDone - Closes the dialog.
  29. //
  30. //    Copier's Helper functions:
  31. //       InitStatusBar - Creates the Progress Bar Control
  32. //       InitTBar - Creates and initializes the Track Bar Control
  33. //       InitUDCtl - Creates the UpDown Control for the given Edit control
  34. //       GetTBarPos - Calculates the Track Bar Control's dimensions
  35. //       UpdateSB - Updates the status bar information about user selection
  36. //       EnableControls - Enables and disables controls
  37. //       StartCopying - Does the copying process and updates user
  38. //       ResetDialog - Resets the dialog with default values
  39. //       StopCopying - Stops the copying process by user's demand
  40. //
  41. //  COMMENTS:
  42. //
  43. //
  44.  
  45. #include <stdlib.h>
  46. #include <windows.h>            // required for all Windows applications
  47. #include <windowsx.h>
  48. #include <commctrl.h>           // required for common controls
  49. #include "globals.h"            // prototypes specific to this application
  50. #include "copier.h"             // prototypes specific to the Copier dialog
  51.  
  52. // Functions for handling dialog window messages.  The message-dispatching
  53. // mechanism expects all message-handling functions to have the following
  54. // prototype:
  55. //
  56. //     LRESULT FunctionName(HWND, UINT, WPARAM, LPARAM);
  57. LRESULT MsgDlgInit(HWND, UINT, WPARAM, LPARAM);
  58. LRESULT MsgDlgCommand(HWND, UINT, WPARAM, LPARAM);
  59. LRESULT MsgDlgHScroll(HWND, UINT, WPARAM, LPARAM);
  60. LRESULT MsgDlgTimer(HWND, UINT, WPARAM, LPARAM);
  61.  
  62. // Functions for handling dialog window commands--ie. functions for
  63. // processing WM_COMMAND messages based on the wParam value.
  64. // The message-dispatching mechanism expects all command-handling
  65. // functions to have the following prototype:
  66. //
  67. //     LRESULT FunctionName(HWND, WORD, WORD, HWND);
  68. LRESULT CmdnCopies(HWND, WORD, WORD, HWND);
  69. LRESULT CmdStart(HWND, WORD, WORD, HWND);
  70. LRESULT CmdReset(HWND, WORD, WORD, HWND);
  71. LRESULT CmdStop(HWND, WORD, WORD, HWND);
  72. LRESULT CmdDone(HWND, WORD, WORD, HWND);
  73.  
  74. // Helper function prototypes used by the COPIER dialog.
  75. HWND InitStatusBar(HWND);
  76. HWND InitTBar(HWND, int, int, int, int, int, int, int, int);
  77. HWND InitUDCtl(HWND, int, int, int, int, int);
  78. void GetTBarPos(HWND, HWND, LPRECT);
  79. void UpdateSB(HWND);
  80. BOOL EnableControls(HWND ,BOOL);
  81. BOOL StartCopying(HWND);
  82. BOOL ResetDialog(HWND);
  83. BOOL StopCopying(HWND, BOOL);
  84.  
  85. // Message and command dispatch infrastructure.  The following type
  86. // definitions and functions are used by the message and command dispatching
  87. // mechanism for the dialog.
  88.  
  89.     // This structure maps COPIER dialog messages to message handling 
  90.     // functions.
  91. MSD rgmsdDlg[] =
  92. {
  93.     {WM_INITDIALOG, MsgDlgInit},
  94.     {WM_COMMAND,    MsgDlgCommand},
  95.     {WM_HSCROLL,    MsgDlgHScroll},
  96.     {WM_TIMER,      MsgDlgTimer} 
  97.  
  98. };
  99.  
  100. MSDI msdiDlg =
  101. {
  102.     sizeof(rgmsdDlg) / sizeof(MSD),
  103.     rgmsdDlg,
  104.     edwpNone
  105. };
  106.  
  107.     // This structure maps COPIER dialogs command IDs to command handling 
  108.     // functions.
  109. CMD rgcmdCtrls[] =
  110. {
  111.     {IDD_NCOPIES,  CmdnCopies},     // displaying number of copies
  112.     {IDOK,         CmdStart},       // Starts Copying
  113.     {IDD_RESET,    CmdReset},       // Resets the copier
  114.     {IDD_STOP,     CmdStop},        // Stops copying 
  115.     {IDCANCEL,     CmdDone}         // Closes the dialog on ESC
  116. };
  117.  
  118. CMDI cmdiCtrls =
  119. {
  120.     sizeof(rgcmdCtrls) / sizeof(CMD),
  121.     rgcmdCtrls,
  122.     edwpNone
  123. };
  124.  
  125.  
  126. // Global variable declarations.
  127. UINT TimerID;                       // Timer ID for the Timer we set.
  128. int iTimeCtr;                       // Timer tick counter
  129. int nCopiesDone;                    // Number of copies completed copying.
  130. int nCopies;                        // Number of copies selected
  131. int iEnlargementPct;                // Enlargement percentage selected
  132. int iShade;                         // Shading selected. 
  133.                                     //       0 ==> lighter
  134.                                     //       1 ==> Ave
  135.                                     //       2 ==> Darker
  136. BOOL fIsCopyState = FALSE;          // TRUE  ==> Copying State
  137.                                     // FALSE ==> Idle or need clear State
  138.  
  139. //
  140. //  FUNCTION: CopierProc(HWND, UINT, WPARAM, LPARAM)
  141. //
  142. //  PURPOSE:  Processes messages for "Copier" dialog box.
  143. //
  144. //  PARAMETERS:
  145. //    hdlg - window handle of the dialog box
  146. //    wMessage - type of message
  147. //    wparam - message-specific information
  148. //    lparam - message-specific information
  149. //
  150. //  RETURN VALUE:
  151. //    TRUE - message handled
  152. //    FALSE - message not handled
  153. //
  154. //  COMMENTS:
  155. //     Display a Copier Panel which demonstrated the use of 4 of the new 
  156. //     Windows 95 Common Controls; Progress Bar, Up/Down Control, Slider Control
  157. //     and Status Bar control.  System menu should be used to exit the dialog
  158. //     box.
  159. //
  160.  
  161. LRESULT CALLBACK CopierProc(HWND hdlg,
  162.                             UINT uMessage,
  163.                             WPARAM wparam,
  164.                             LPARAM lparam)
  165. {
  166.     return DispMessage(&msdiDlg, hdlg, uMessage, wparam, lparam);
  167. }
  168.  
  169. //
  170. //  FUNCTION: MsgDlgInit(HWND, UINT, WPARAM, LPARAM)
  171. //
  172. //  PURPOSE: Performs initializations necessary for the Copier dialog box.
  173. //
  174. //  PARAMETERS:
  175. //    hdlg - The window handing the message.
  176. //    uMessage - The message number. (unused).
  177. //    wparam - Message specific data (unused).
  178. //    lparam - Message specific data (unused).
  179. //
  180. //  RETURN VALUE:
  181. //    TRUE - message handled.
  182. //
  183. //  COMMENTS:
  184. //     This function processed the code for WM_INITDIALOG for the Copier
  185. //     dialog box.  The initialization steps are as follows:
  186. //     1) Initializing of global variables used by the dialog.
  187. //     2) default values are stored for use when resetting the dialog.  The
  188. //        default values are stored using SetProp()
  189. //     3) Initialize the state of the controls
  190. //     4) Load the common control DLL.
  191. //     5) Create and initialize the Status bar.
  192. //     6) Create and initialize the Enlargement Track bar control.
  193. //     7) Create and initialize the Shading Track bar control.
  194. //     8) Create and initialize the Up/Down control.
  195. //
  196.  
  197. #pragma argsused
  198. LRESULT MsgDlgInit(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  199. {
  200.     HWND hCtl;
  201.     RECT rc;
  202.  
  203.     // Initialize globals
  204.     iTimeCtr = 0;
  205.     nCopies = 1;
  206.     iEnlargementPct = 100;
  207.     iShade = 1;
  208.  
  209.     // Save the default values to be use by the resetting function.
  210.     SetProp(hdlg, "defcopy", (HANDLE)nCopies);
  211.     SetProp(hdlg, "defenlrg", (HANDLE)(iEnlargementPct / 10));
  212.     SetProp(hdlg, "defshade", (HANDLE)iShade);
  213.  
  214.     // Disable the cancel button. This button is only used to cancel 
  215.     // copying.
  216.     hCtl = GetDlgItem(hdlg, IDD_STOP);
  217.     EnableWindow(hCtl, FALSE);
  218.     
  219.     // Load the common control DLL
  220.      InitCommonControls();
  221.  
  222.     // Create and initialize the Progress Bar
  223.     if (!InitStatusBar(hdlg))
  224.     {
  225.         MessageBeep(0);
  226.         return TRUE;
  227.     }
  228.  
  229.     // Get the dimentions for the Track Bar
  230.     GetTBarPos(hdlg, GetDlgItem(hdlg, IDD_ENLARGE), &rc);
  231.  
  232.     // Create and initialize the Track Bar
  233.     if (!InitTBar(hdlg,                      
  234.                   IDD_TBENLARGE,
  235.                   rc.left, rc.top,           // x,y position of the track bar
  236.                   (rc.right - rc.left),      // widht of the track bar
  237.                   30,                        // height of the track bar
  238.                   0, 20,                     // Min and Max of the Track bar
  239.                   (iEnlargementPct / 10)))   // Initial position of Track bar
  240.     {
  241.         MessageBeep(0);
  242.         return TRUE;
  243.     }
  244.  
  245.     // Get the dimentions for the Track Bar
  246.     GetTBarPos(hdlg, GetDlgItem(hdlg, IDD_DARK), &rc);
  247.  
  248.     // Create and initialize the Track Bar
  249.     if (!InitTBar(hdlg,
  250.                   IDD_TBDARK,
  251.                   rc.left, rc.top,           // x,y position of the track bar
  252.                   (rc.right - rc.left),      // widht of the track bar
  253.                   30,                        // height of the track bar
  254.                   0, 2,                      // Min and Max of the Track bar
  255.                   iShade))                   // Initial position of Track bar
  256.     {
  257.         MessageBeep(0);
  258.         return TRUE;
  259.     }
  260.  
  261.     // Create and initialize the Up/Down for the Range Edit control
  262.     if (!InitUDCtl(hdlg, IDD_NCOPIES, IDD_UDCOPIES, 50, 0, nCopies))
  263.     {
  264.         MessageBeep(0);
  265.         return TRUE;
  266.     }
  267.  
  268.     return TRUE;
  269. }
  270.  
  271. //
  272. //  FUNCTION: MsgDlgCommand(HWND, UINT, WPARAM, LPARAM)
  273. //
  274. //  PURPOSE: Process WM_COMMAND message sent to the "Copier" Dialog Box.
  275. //
  276. //  PARAMETERS:
  277. //    hwnd - The window handing the message (handle of copier dialog window).
  278. //    uMessage - The message number.
  279. //    wparam - Message specific data.
  280. //    lparam - Message specific data.
  281. //
  282. //  RETURN VALUE:
  283. //    TRUE - message handled.
  284. //
  285. //  COMMENTS:
  286. //    Uses this DispCommand function defined in wndproc.c combined
  287. //    with the cmdiCtrls structure defined in COPIER.H file to handle
  288. //    the command messages for the Copier dialog box.
  289. //
  290.  
  291. #pragma argsused
  292. LRESULT MsgDlgCommand (HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  293. {
  294.      return DispCommand(&cmdiCtrls, hwnd, wparam, lparam);
  295. }
  296.  
  297. //
  298. //  FUNCTION: MsgDlgHScroll(HWND, UINT, WPARAM, LPARAM)
  299. //
  300. //  PURPOSE: Process WM_HSCROLL message sent to the "Copier" Dialog Box.
  301. //
  302. //  PARAMETERS:
  303. //    hdlg - The window handing the message.
  304. //    uMessage - The message number. (unused).
  305. //    wparam - Message specific data.
  306. //    lparam - Message specific data.
  307. //
  308. //  RETURN VALUE:
  309. //    TRUE - message handled.
  310. //
  311. //  COMMENTS:
  312. //    This message is processed for tracking the Track bar changes in the
  313. //    dialog box.  The parent of a Track bar control is notified of a  
  314. //    changes by user action, through WM_HSCROLL messages.
  315. //          uMessage - WM_HSCROLL
  316. //          wparam   - Low-order word of wparam contains the notification
  317. //                     code and high-order word the new position. 
  318. //                     NOTE:
  319. //                     The position is only passed for TB_THUMBPOSITION and
  320. //                     or SB_THUMBTRACK. 
  321. //          lparam   - handle of the track bar control
  322. //
  323.  
  324. #pragma argsused
  325. LRESULT MsgDlgHScroll(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  326. {
  327.     int iCtrlID;
  328.     HWND hCtl;
  329.     int  iNotify;
  330.  
  331.     //  Only when the notification message is TB_THUMBPOSITION and the slider 
  332.     //  thumb is dragged, the value of wparam is the position of the slider 
  333.     //  thumb but not when clicking around on the slider control.  For all 
  334.     //  other notification message the HIWORD(wparam) is 0.  TBM_GETPOS
  335.     //  message can be send to retrieve the position of the slider thumb.
  336.      iNotify = LOWORD(wparam);
  337.  
  338.     if (iNotify == TB_ENDTRACK)
  339.     {
  340.         hCtl = (HWND)lparam;
  341.         iCtrlID = (int)GetDlgCtrlID(hCtl);
  342.         if (iCtrlID == IDD_TBENLARGE)
  343.             iEnlargementPct = 10 * (int)SendMessage(hCtl, TBM_GETPOS, 0, 0);
  344.         else if (iCtrlID == IDD_TBDARK)
  345.             iShade = (int)SendMessage(hCtl, TBM_GETPOS, 0, 0);
  346.  
  347.         UpdateSB(hdlg);
  348.     }
  349.  
  350.     return TRUE;
  351. }
  352.  
  353. //
  354. //  FUNCTION: MsgDlgTimer(HWND, UINT, WPARAM, LPARAM)
  355. //
  356. //  PURPOSE: Process WM_TIMER message sent to the "Copier" Dialog Box.
  357. //
  358. //  PARAMETERS:
  359. //    hdlg - The window handing the message.
  360. //    uMessage - The message number. (unused).
  361. //    wparam - Message specific data (unused).
  362. //    lparam - Message specific data (unused).
  363. //
  364. //  RETURN VALUE:
  365. //    TRUE - message handled.
  366. //
  367. //  COMMENTS:
  368. //    This code pretends to copy documents.  The time to complete a copy
  369. //    is arbitrarily set to 3.  With in this function the progress bar is
  370. //    demonstrated and the status bar is updated to relay the copying 
  371. //    information to the user. Progress bar is stepped every time one copy
  372. //    is completed.  The amount used to step is calculated and set with in
  373. //    the StartCopying() function below.
  374. //
  375.  
  376. #pragma argsused
  377. LRESULT MsgDlgTimer(HWND hdlg, UINT uMessage, WPARAM wparam, LPARAM lparam)
  378. {
  379.     static int iPctLeft;
  380.     HWND hStatus;
  381.     HWND hPGBar;
  382.     HWND hCtl;
  383.  
  384.     if (!iTimeCtr)
  385.         iPctLeft = 100;               // first timer tick initialise iPctLeft
  386.  
  387.     ++iTimeCtr;                       // increment the timer tick
  388.  
  389.     if ((iTimeCtr % 3) == 0)          // 3 timer ticks per copy
  390.      {
  391.         char szbuf[20];
  392.  
  393.         if (nCopies)                  // only increment if copies selected
  394.             ++nCopiesDone;            // another copy completed
  395.  
  396.         // Update the status bar text with number of copies completed
  397.         hStatus = GetDlgItem(hdlg, IDD_STATUSBAR);
  398.         wsprintf(szbuf, "%i Copies Completed", nCopiesDone);
  399.         SendMessage(hStatus, SB_SETTEXT, (WPARAM)1|0, (LPARAM)&szbuf);
  400.  
  401.         hPGBar = GetDlgItem(hdlg, IDD_PGBAR);
  402.  
  403.           // if this is the last one use DeltaPos to catch roundings that
  404.         // may have occured.
  405.         if (nCopiesDone == nCopies)
  406.         {  
  407.             SendMessage(hPGBar, PBM_DELTAPOS, (WPARAM)iPctLeft, 0);
  408.             iPctLeft = 0;
  409.                 StopCopying(hdlg, TRUE);
  410.           }
  411.           else // just use one step per each completed copy.
  412.           {
  413.                 int nStep;
  414.  
  415.                 SendMessage(hPGBar, PBM_STEPIT, 0, 0);
  416.  
  417.                 nStep = 100;
  418.                 if (nCopies)
  419.                 nStep = nStep / nCopies;
  420.  
  421.             iPctLeft -= nStep;
  422.             if (iPctLeft <= 0)
  423.                 iPctLeft = 0;
  424.         }
  425.     }
  426.  
  427.     // Set the focus back to the "Cancel" button
  428.     hCtl = GetDlgItem(hdlg, IDD_STOP);
  429.      SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hCtl, (LPARAM)TRUE);
  430.  
  431.     return TRUE;
  432. }
  433.  
  434. //
  435. //  FUNCTION: CmdnCopies(HWND, WORD, HWND)
  436. //
  437. //  PURPOSE: Checking the input for number of copies
  438. //   
  439. //  PARAMETERS:
  440. //    hdlg - The window handling the command.
  441. //    wCommand - The command to be handled (unused).
  442. //    hwndCtrl - NULL (unused).
  443. //
  444. //  RETURN VALUE:
  445. //    Always returns TRUE.
  446. //
  447. //  COMMENTS:
  448. //    This is the code for WM_COMMAND with wParam == IDD_NCOPIES.  Processing
  449. //    the EN_UPDATE notification message to check validity of input.  If the
  450. //    input is invalid the status bar displays a message with the copy limits.
  451. //    The global that holds the number of copies is not updated if the input
  452. //    is invalid.
  453. //
  454.  
  455. #pragma argsused
  456. LRESULT CmdnCopies(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  457. {
  458.      char szbuf[20];
  459.      HWND hStatus;                // Handle to the Status Bar control
  460.      int  iInCopies;
  461.  
  462.  
  463.     if (wNotify == EN_UPDATE)
  464.     {
  465.         GetWindowText(hwndCtrl, szbuf, 4);
  466.         iInCopies = atoi(szbuf);
  467.         hStatus = GetDlgItem(hdlg, IDD_STATUSBAR);
  468.         if ((iInCopies > 50) || (iInCopies < 0))
  469.         { 
  470.             MessageBeep(0);
  471.             SendMessage(hStatus,
  472.                         SB_SETTEXT,
  473.                         (WPARAM)2|SBT_NOBORDERS,
  474.                                 (LPARAM)(LPSTR)"Num Copies 0-50");
  475.        
  476.             return FALSE;
  477.         }
  478.         else
  479.         {
  480.             nCopies = iInCopies;
  481.             UpdateSB(hdlg);
  482.             SendMessage(hStatus,
  483.                         SB_SETTEXT,
  484.                         (WPARAM)2|SBT_NOBORDERS,
  485.                         (LPARAM)(LPSTR)"");
  486.         }
  487.      }
  488.  
  489.  
  490.     return TRUE;
  491. }
  492.  
  493. //
  494. //  FUNCTION: CmdStart(HWND, WORD, HWND)
  495. //
  496. //  PURPOSE: Starts the copying process by calling StartCopying() function.
  497. //   
  498. //  PARAMETERS:
  499. //    hdlg - The window handling the command.
  500. //    wCommand - The command to be handled (unused).
  501. //    hwndCtrl - NULL (unused).
  502. //
  503. //  RETURN VALUE:
  504. //    Always returns TRUE.
  505. //
  506. //  COMMENTS:
  507. //    This is the code for WM_COMMAND with wParam == IDOK.  
  508. //
  509.  
  510. #pragma argsused
  511. LRESULT CmdStart(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  512. {
  513.     HWND hCtl;
  514.  
  515.     
  516.     // Update the edit control and the status bar incase bad input was 
  517.     // entered.
  518.     hCtl = GetDlgItem(hdlg, IDD_UDCOPIES);
  519.      SendMessage(hCtl, UDM_SETPOS, (WPARAM)0, (LPARAM)MAKELONG(nCopies, 0));
  520.  
  521.     // Start the actual copying.
  522.     StartCopying(hdlg);
  523.  
  524.     return TRUE;
  525. }
  526.  
  527. //
  528. //  FUNCTION: CmdReset(HWND, WORD, HWND)
  529. //
  530. //  PURPOSE: Resets the Copier dialog box with the default values.
  531. //
  532. //  PARAMETERS:
  533. //    hdlg - The window handling the command.
  534. //    wCommand - The command to be handled (unused).
  535. //    hwndCtrl - NULL (unused).
  536. //
  537. //  RETURN VALUE:
  538. //    Always returns TRUE.
  539. //
  540. //  COMMENTS:
  541. //    This is the code for WM_COMMAND with wParam == IDD_RESET.
  542. //
  543.  
  544. #pragma argsused
  545. LRESULT CmdReset(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  546. {
  547.     HWND hCtl;
  548.  
  549.     // Enable the controls and set the focus to the START button
  550.     EnableControls(hdlg, TRUE);
  551.     hCtl = GetDlgItem(hdlg, IDOK);
  552.     SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hCtl, (LPARAM)TRUE);
  553.  
  554.     // Reset the dialog to its initial setup.
  555.      return ResetDialog(hdlg);
  556. }
  557.  
  558. //
  559. //  FUNCTION: CmdStop(HWND, WORD, HWND)
  560. //
  561. //  PURPOSE: Stop/Interupts the copying process by calling StopCopying().
  562. //           The dialog needs to be reset before other jobs could be 
  563. //           processed.
  564. //
  565. //  PARAMETERS:
  566. //    hdlg - The window handling the command.
  567. //    wCommand - The command to be handled (unused).
  568. //    hwndCtrl - NULL (unused).
  569. //
  570. //  RETURN VALUE:
  571. //    Always returns TRUE.
  572. //
  573. //  COMMENTS:
  574. //    This is the code for WM_COMMAND with wParam == IDD_STOP.  
  575. //
  576.  
  577. #pragma argsused
  578. LRESULT CmdStop(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  579. {
  580.     return StopCopying(hdlg, FALSE);
  581. }
  582.  
  583. //
  584. //  FUNCTION: CmdDone(HWND, WORD, HWND)
  585. //
  586. //  PURPOSE: Close the Copier dialog box and free its related data.
  587. //
  588. //  PARAMETERS:
  589. //    hdlg - The window handling the command.
  590. //    wCommand - The command to be handled (unused).
  591. //    hwndCtrl - NULL (unused).
  592. //
  593. //  RETURN VALUE:
  594. //    Always returns TRUE.
  595. //
  596. //  COMMENTS:
  597. //    This is the code for WM_COMMAND with wParam == IDCANCEL.  Calls 
  598. //    EndDialog to finish the dialog session.
  599. //
  600.  
  601. #pragma argsused
  602. LRESULT CmdDone(HWND hdlg, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  603. {
  604.      RemoveProp(hdlg, "defcopy");
  605.      RemoveProp(hdlg, "defenlrg");
  606.      RemoveProp(hdlg, "defshade");
  607.      EndDialog(hdlg, TRUE);          // Exit the dialog
  608.  
  609.     return TRUE;
  610. }
  611.  
  612. //
  613. //  FUNCTION: InitStatusBar(HWND)
  614. //
  615. //  PURPOSE: Creates and initializes the Status Bar control and the Progress
  616. //           Bar control
  617. //
  618. //  PARAMETERS:
  619. //    hdlg - The dialogs window handle.
  620. //
  621. //  RETURN VALUE:
  622. //    Handle of the Status Bar if successful
  623. //
  624. //  COMMENTS:
  625. //
  626.  
  627. HWND InitStatusBar(HWND hdlg)
  628. {
  629.     #define SBP_COPYTXT   50            // 1st - "Copy:"
  630.     #define SBP_COPYSTAT 250            // 2nd - Copying selected
  631.     #define SBP_PGBAR    380            // 3rd - Progress bar or error message 
  632.     #define SBP_DLGSTAT   -1            // 4th - Status of the dialog
  633.  
  634.     int ptSBParts[4] = {SBP_COPYTXT,
  635.                         SBP_COPYSTAT,
  636.                         SBP_PGBAR,
  637.                         SBP_DLGSTAT} ;  // The number of parts/sections
  638.     HWND hStatus;                       // Status Bar control handle
  639.     HWND hPGBar;                        // Progress Bar control handle
  640.     RECT rc;                            // Status bar Rect 
  641.     int  sbBorders[3];                  // Status bar border information
  642.     int  x, y, width, height;           // Progress bar co-ordinates
  643.  
  644.     hStatus = CreateWindow(STATUSCLASSNAME,
  645.                            "Statusbar Sample",
  646.                            WS_CHILD | WS_VISIBLE | WS_BORDER,
  647.                            0, 0, 0, 0,                // these are ignored
  648.                            hdlg,
  649.                            (HMENU)IDD_STATUSBAR,
  650.                            hInst,
  651.                            NULL);
  652.  
  653.     if (hStatus)
  654.     {
  655.         // Set the parts for the status bar.  the number '4' indicated here 
  656.         // matches the number of parts passed in ptSBParts.
  657.         SendMessage(hStatus, SB_SETPARTS, 4, (LPARAM)(LPINT)ptSBParts);
  658.  
  659.         // Initialize each of the status bar parts.
  660.         SendMessage(hStatus,
  661.                     SB_SETTEXT,
  662.                     (WPARAM)0|SBT_NOBORDERS,
  663.                     (LPARAM)(LPSTR)"Copy:");
  664.         UpdateSB(hdlg);
  665.         SendMessage(hStatus,
  666.                     SB_SETTEXT,
  667.                     (WPARAM)2|SBT_NOBORDERS,
  668.                     (LPARAM)(LPSTR)"");
  669.         SendMessage(hStatus,
  670.                     SB_SETTEXT,
  671.                     (WPARAM)3|0,
  672.                     (LPARAM)(LPSTR)"Idle");
  673.     }
  674.     else
  675.         return NULL;
  676.  
  677.     // Calculate the dimensions of the progress bar with respect to the
  678.     // Status bar by:
  679.     //
  680.     //  1) Get the client area of the status bar and convert its co-ordinates
  681.     //        to the client co-ordinates of the dialog since progress bar is
  682.     //        child of the dialog.
  683.     //  2) Get the border dimentions of the status bar using SB_GETBORDERS
  684.     //  3) Place the progress bar after where copying status is (SBP_COPYSTAT).
  685.     //        Use the dimensions of the status bar and the border values 
  686.     //        retrieved and calculate the x, y, width and height of the 
  687.     //        progress bar.
  688.     GetClientRect(hStatus, &rc);
  689.     MapWindowPoints(hStatus, hdlg, (LPPOINT)&rc.left, 2);
  690.  
  691.     SendMessage(hStatus, SB_GETBORDERS, (WPARAM)0, (LPARAM)&sbBorders);
  692.  
  693.     x = rc.left + SBP_COPYSTAT + (sbBorders[2] / 2);
  694.     y = rc.top + (2 * sbBorders[1]);
  695.     width = SBP_PGBAR - SBP_COPYSTAT;
  696.     height = rc.bottom - rc.top - (4 * sbBorders[1]);
  697.  
  698.     // Create the progress bar.  The Progress bar range 0-100 by default
  699.     // and its step increment is 10 by default.  These default values are
  700.     // displayed in the edit controls.
  701.     hPGBar = CreateWindow(PROGRESS_CLASS,
  702.                           "Progress Bar",
  703.                           WS_VISIBLE | WS_CHILD,
  704.                           x,
  705.                           y,
  706.                           width,
  707.                           height,
  708.                           hdlg,
  709.                           (HMENU)IDD_PGBAR,
  710.                           hInst,
  711.                           NULL);
  712.     if (hPGBar)
  713.         ShowWindow(hPGBar, SW_HIDE);
  714.  
  715.     return hStatus;
  716. }
  717.  
  718. //
  719. //  FUNCTION: InitTBar(HWND)
  720. //
  721. //  PURPOSE: Creates and initializes the Track bar control
  722. //
  723. //  PARAMETERS:
  724. //    hdlg - The dialogs window handle.
  725. //    IDTB - ID of the Track bar to be created.
  726. //    x - x position of the where the control is created.
  727. //    y - y position of the where the control is created.
  728. //    nWidth - Width of the Track bar control.
  729. //    nHeight - Height of the Track bar control.
  730. //    nMin - The minumum range of the Track bar.
  731. //    nMax - The maximum range of the Track bar.
  732. //    nPos - The initial thumb position of the Track bar.
  733. //
  734. //  RETURN VALUE:
  735. //    Handle of the Track bar if successful
  736. //
  737. //  COMMENTS:
  738. //
  739.  
  740. HWND InitTBar(HWND hdlg,
  741.               int IDTB,
  742.               int x,
  743.               int y,
  744.               int nWidth,
  745.               int nHeight,
  746.               int nMin,
  747.               int nMax,
  748.               int nPos)
  749. {
  750.     HWND hTBar;
  751.  
  752.     // Create the track bar window with TBS_AUTOTICKS which draws and updates
  753.     // the ticks automatically.
  754.     hTBar = CreateWindow(TRACKBAR_CLASS,
  755.                          "Track Bar",
  756.                          TBS_AUTOTICKS | WS_VISIBLE | WS_CHILD | WS_TABSTOP,
  757.                          x,
  758.                          y,
  759.                          nWidth,
  760.                          nHeight,
  761.                          hdlg,
  762.                          (HMENU)IDTB,
  763.                          hInst,
  764.                          NULL);
  765.  
  766.     if (hTBar)
  767.     {
  768.         // Set the minimum and maximum range of the track bar.
  769.         SendMessage(hTBar,
  770.                     TBM_SETRANGE,
  771.                     (WPARAM)(BOOL)TRUE,
  772.                     (LPARAM)MAKELONG(nMin, nMax));
  773.  
  774.         // Set the track bar thumb to the specified position.
  775.         SendMessage(hTBar,
  776.                     TBM_SETPOS,
  777.                     (WPARAM)(BOOL)TRUE,
  778.                     (LPARAM)(LONG)nPos);
  779.     }
  780.  
  781.     return hTBar;
  782. }
  783.  
  784. //
  785. //  FUNCTION: InitUDCtl(HWND, int)
  786. //
  787. //  PURPOSE: Creates and initializes the Up/Down control
  788. //
  789. //  PARAMETERS:
  790. //    hdlg - The dialogs window handle.
  791. //    IDEdit - ID of the edit control to contain the Up/Down control
  792. //    IDUD - ID of the Up/Down control
  793. //    nUpper - The upper limit of the Up/Down control
  794. //    nLower - The lower limit of the Up/Down control
  795. //    nPos - The initial position of the the Up/Down control
  796. //
  797. //  RETURN VALUE:
  798. //    Handle of the Up/Down Control if successful.
  799. //
  800. //  COMMENTS:
  801. //
  802.  
  803. HWND InitUDCtl(HWND hdlg,
  804.                int IDEdit,
  805.                int IDUD,
  806.                int nUpper,
  807.                int nLower,
  808.                int nPos)
  809. {
  810.     HWND hEdit;
  811.     HWND hUDCtl;
  812.     RECT rc;
  813.     int  cx, cy, x, y;
  814.  
  815.     // Get the handle of the edit control which is used as the buddy of the
  816.     // Up/Down control.  The dialog is still the parent of the control.
  817.     // This UD control is using the right align style and which aligns the
  818.     // UD control to the right border of the buddy and ignores the x,y,cx
  819.     // and cy values.  x, y, cx and cy are place here to demonstrate how
  820.     // the Up/Down control can be placed in the buddy manually!
  821.     hEdit = GetDlgItem(hdlg, IDEdit);
  822.     GetClientRect(hEdit, &rc);
  823.     MapWindowPoints(hEdit, hdlg, (LPPOINT)&rc.left, 2);
  824.  
  825.     cx = 10;
  826.     cy = (rc.bottom - rc.top) + 2;
  827.     x  = rc.right;
  828.     y  = rc.top - 1;
  829.  
  830.     // Create the Up/Down control. 
  831.     // NOTE: Since UDS_ALIGNRIGHT is used, x, y, cx and cy are ignored.
  832.     //       Remove UDS_ALIGNRIGHT and the UD control can be placed any where.
  833.     hUDCtl = CreateWindow(UPDOWN_CLASS,
  834.                           NULL,
  835.                           WS_CHILD | WS_BORDER | WS_VISIBLE |
  836.                           UDS_WRAP | UDS_ARROWKEYS |
  837.                           UDS_ALIGNRIGHT | UDS_SETBUDDYINT, 
  838.                           x, y,
  839.                           cx, cy,
  840.                           hdlg,              // handle of the parent
  841.                           (HMENU)IDUD,       // ID of the UD control
  842.                           hInst,
  843.                           NULL);
  844.  
  845.     if (hUDCtl)
  846.     {
  847.         // Set the buddy for the Up/Down control and initialize the lower
  848.         // and upper limit of the control and its initial position
  849.         SendMessage(hUDCtl, UDM_SETBUDDY, (WPARAM)hEdit, 0L);
  850.         SendMessage(hUDCtl, UDM_SETRANGE, 0, (LPARAM)MAKELONG(nUpper, nLower));
  851.         SendMessage(hUDCtl, UDM_SETPOS, 0, (LPARAM)MAKELONG(nPos, 0));
  852.     }
  853.  
  854.     return hUDCtl;
  855. }
  856.  
  857. //
  858. //  FUNCTION: GetTBarPos(HWND, HWND, LPRECT)
  859. //
  860. //  PURPOSE: Calculates the position of the Track bar control based on its
  861. //    its static text title.
  862. //
  863. //  PARAMETERS:
  864. //    hdlg - Handle of the dialog.
  865. //    hStatic - The related Static control handle.
  866. //    lprc - When returned contains the position of the Track Bar Control
  867. //
  868. //  RETURN VALUE:
  869. //    None
  870. //
  871. //  COMMENTS:
  872. //
  873.  
  874. void GetTBarPos(HWND hdlg, HWND hStatic, LPRECT lprc)
  875. {
  876.     RECT strc;          // Rectangle containing the static control
  877.  
  878.     // Get the dimentions of the static window containing the Track bar
  879.     // header.
  880.     GetWindowRect(hStatic,&strc);
  881.  
  882.     // Convert the rectangle from screen units to client units relative to
  883.     // the dialog box.
  884.     ScreenToClient(hdlg, (LPPOINT)&strc.left);
  885.     ScreenToClient(hdlg, (LPPOINT)&strc.right);
  886.  
  887.     // return the calculated rect for the track bar.
  888.     lprc->left   = strc.left;
  889.     lprc->right  = strc.right;
  890.     lprc->top    = strc.bottom + 2;
  891.     lprc->bottom = lprc->top + (strc.bottom - strc.top);
  892.  
  893.     return;
  894. }
  895.  
  896. //
  897. //  FUNCTION: UpdateSB(HWND hdlg)
  898. //
  899. //  PURPOSE: Updates the status bar text for the copy information
  900. //
  901. //  PARAMETERS:
  902. //    hdlg - Handle of the dialog
  903. //
  904. //  RETURN VALUE:
  905. //    None
  906. //
  907. //  COMMENTS:
  908. //
  909.  
  910. void UpdateSB(HWND hdlg)
  911. {
  912.     HWND hStatus;
  913.     char szbuf[80];
  914.     char Shade[20];
  915.  
  916.     // Get the text associated with the shadings
  917.     if (!iShade)
  918.         lstrcpy(Shade, "Lighter");
  919.     else if (iShade == 2)
  920.         lstrcpy(Shade, "Darker");
  921.     else
  922.         lstrcpy(Shade, "Auto");
  923.  
  924.     hStatus = GetDlgItem(hdlg, IDD_STATUSBAR);
  925.  
  926.     // Show users current selection on the copier panel
  927.     wsprintf(szbuf, "%i at %i%% with %s Shading",
  928.              nCopies,
  929.              iEnlargementPct,
  930.              Shade);
  931.     SendMessage(hStatus, SB_SETTEXT, (WPARAM)1|0, (LPARAM)&szbuf);
  932.  
  933.     return;
  934. }
  935.  
  936. //
  937. //  FUNCTION: EnableControls(HWND, BOOL)
  938. //
  939. //  PURPOSE: Enables or Disables controls based on the passed parameter
  940. //
  941. //  PARAMETERS:
  942. //    hdlg - The dialogs window handle.
  943. //    fEnable - flag determining whether the window should be enabled or 
  944. //       disabled.
  945. //
  946. //  RETURN VALUE:
  947. //    Always returns TRUE.
  948. //
  949. //  COMMENTS:
  950. //
  951.  
  952. BOOL EnableControls(HWND hdlg, BOOL fEnable)
  953. {
  954.     HWND hCtl;
  955.  
  956.     // Number of Copies edit control is disabled while copying
  957.     hCtl = GetDlgItem(hdlg, IDD_NCOPYTXT);
  958.     EnableWindow(hCtl, fEnable);
  959.     hCtl = GetDlgItem(hdlg, IDD_NCOPIES);
  960.     EnableWindow(hCtl, fEnable);
  961.  
  962.     // Start button is disabled while copying
  963.     hCtl = GetDlgItem(hdlg, IDOK);
  964.     EnableWindow(hCtl, fEnable);
  965.  
  966.     // Re-Set Button is disabled while copying
  967.     hCtl = GetDlgItem(hdlg, IDD_RESET);
  968.     EnableWindow(hCtl, fEnable);
  969.  
  970.     // Enlargement Tracker control is disabled while copying
  971.     hCtl = GetDlgItem(hdlg, IDD_ENLARGE);
  972.     EnableWindow(hCtl, fEnable);
  973.     hCtl = GetDlgItem(hdlg, IDD_TBENLARGE);
  974.     EnableWindow(hCtl, fEnable);
  975.  
  976.     // Darkness Tracker control is disabled while copying
  977.     hCtl = GetDlgItem(hdlg, IDD_DARK);
  978.     EnableWindow(hCtl, fEnable);
  979.     hCtl = GetDlgItem(hdlg, IDD_TBDARK);
  980.     EnableWindow(hCtl, fEnable);
  981.  
  982.     // This button is Cancel when copying and Clear when Idle
  983.     hCtl = GetDlgItem(hdlg, IDD_STOP);
  984.     EnableWindow(hCtl, !fEnable);
  985.  
  986.     return TRUE;
  987. }
  988.  
  989. //
  990. //  FUNCTION: StartCopying(HWND hdlg)
  991. //
  992. //  PURPOSE: Start the copying process
  993. //
  994. //  PARAMETERS:
  995. //    hdlg - Handle of the dialog
  996. //
  997. //  RETURN VALUE:
  998. //    TRUE always
  999. //
  1000. //  COMMENTS:
  1001. //    The basic initialization for the copy process is done here.  The
  1002. //    Progress Bar steps are set here (the default is 10). Then a timer 
  1003. //    is set.
  1004. //
  1005.  
  1006. BOOL StartCopying(HWND hdlg)
  1007. {
  1008.     HWND hCtl;
  1009.     HWND hPGBar;
  1010.     int  nStep;
  1011.  
  1012.     // Set the copy flag.  It gets reset either in StopCopying.
  1013.     fIsCopyState = TRUE;
  1014.  
  1015.     // Disable the controls
  1016.     EnableControls(hdlg, FALSE);
  1017.  
  1018.     // Set the focus to the Cancel button
  1019.     hCtl = GetDlgItem(hdlg, IDD_STOP);
  1020.     SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hCtl, (LPARAM)TRUE);
  1021.     
  1022.     // Update the status bar with the new information
  1023.     UpdateSB(hdlg);
  1024.     hCtl = GetDlgItem(hdlg, IDD_STATUSBAR);
  1025.     SendMessage(hCtl, SB_SETTEXT, (WPARAM)3|0, (LPARAM)(LPSTR)"Copying");
  1026.  
  1027.     // display the progress bar
  1028.     hCtl = GetDlgItem(hdlg, IDD_PGBAR);
  1029.     ShowWindow(hCtl, SW_SHOW);
  1030.  
  1031.     // Set the Steps for Progress bar
  1032.     nStep = 100;
  1033.     if (nCopies)
  1034.         nStep = nStep / nCopies;
  1035.     hPGBar = GetDlgItem(hdlg, IDD_PGBAR);
  1036.     SendMessage(hPGBar, PBM_SETSTEP, (WPARAM)nStep, 0);
  1037.  
  1038.     // Start the timer for "pretend copying"
  1039.     iTimeCtr = 0;
  1040.     nCopiesDone = 0;
  1041.     TimerID = SetTimer(hdlg, 1, 250, NULL);
  1042.  
  1043.     return TRUE;
  1044. }
  1045.  
  1046. //
  1047. //  FUNCTION: ResetDialog(HWND hdlg)
  1048. //
  1049. //  PURPOSE: Resets the dialog to its default values
  1050. //
  1051. //  PARAMETERS:
  1052. //    hdlg - Handle of the dialog
  1053. //
  1054. //  RETURN VALUE:
  1055. //    TRUE always
  1056. //
  1057. //  COMMENTS:
  1058. //
  1059.  
  1060. BOOL ResetDialog(HWND hdlg)
  1061. {
  1062.     HWND hCtl;
  1063.  
  1064.     // Reset the Number of Copies edit control through its Up/Down control
  1065.     nCopies = (int)GetProp(hdlg, "defcopy");
  1066.     hCtl = GetDlgItem(hdlg, IDD_UDCOPIES);
  1067.     SendMessage(hCtl, UDM_SETPOS, (WPARAM)0, (LPARAM)MAKELONG(nCopies, 0));
  1068.  
  1069.     // Reset the Enlargement Percentage track bar
  1070.     iEnlargementPct = (int)GetProp(hdlg, "defenlrg");
  1071.     hCtl = GetDlgItem(hdlg, IDD_TBENLARGE);
  1072.     SendMessage(hCtl,
  1073.                 TBM_SETPOS,
  1074.                 (WPARAM)(BOOL)TRUE,
  1075.                 (LPARAM)(LONG)iEnlargementPct);
  1076.     iEnlargementPct = iEnlargementPct * 10;
  1077.  
  1078.     // Reset the Shading density track bar
  1079.     iShade = (int)GetProp(hdlg, "defshade");
  1080.     hCtl = GetDlgItem(hdlg, IDD_TBDARK);
  1081.     SendMessage(hCtl,
  1082.                 TBM_SETPOS,
  1083.                 (WPARAM)(BOOL)TRUE,
  1084.                 (LPARAM)(LONG)iShade);
  1085.  
  1086.     // Update the dialogs status to Idle
  1087.     hCtl = GetDlgItem(hdlg, IDD_STATUSBAR);
  1088.     SendMessage(hCtl, SB_SETTEXT, (WPARAM)3|0, (LPARAM)(LPSTR)"Idle");
  1089.  
  1090.     // Update the status bar
  1091.     UpdateSB(hdlg);
  1092.  
  1093.     // Hide and reset the progress bar
  1094.     hCtl = GetDlgItem(hdlg, IDD_PGBAR);
  1095.     ShowWindow(hCtl, SW_HIDE);
  1096.     SendMessage(hCtl, PBM_SETPOS, (WPARAM)0, (LPARAM)0);
  1097.  
  1098.     return TRUE;
  1099. }
  1100.  
  1101. //
  1102. //  FUNCTION: StopCopying(HWND hdlg,BOOL fIsComplete)
  1103. //
  1104. //  PURPOSE: Stops the copying process
  1105. //
  1106. //  PARAMETERS:
  1107. //    hdlg - Handle of the dialog
  1108. //
  1109. //  RETURN VALUE:
  1110. //    TRUE always
  1111. //
  1112. //  COMMENTS:
  1113. //    Basic clean up.  The Progress Bar is reset when the copying is complete.
  1114. //
  1115.  
  1116. BOOL StopCopying(HWND hdlg, BOOL fIsComplete)
  1117. {
  1118.     HWND hCtl;
  1119.  
  1120.     if (fIsComplete)
  1121.     {
  1122.         MessageBeep(0);             // Anounce completion
  1123.  
  1124.         // Update the status bar with the new information
  1125.         UpdateSB(hdlg);
  1126.         hCtl = GetDlgItem(hdlg, IDD_STATUSBAR);
  1127.         SendMessage(hCtl, SB_SETTEXT, (WPARAM)3|0, (LPARAM)(LPSTR)"Idle");
  1128.   
  1129.         // Hide and reset the progress bar
  1130.         hCtl = GetDlgItem(hdlg, IDD_PGBAR);
  1131.         ShowWindow(hCtl, SW_HIDE);
  1132.         SendMessage(hCtl, PBM_SETPOS, (WPARAM)0, (LPARAM)0);
  1133.  
  1134.         // Enable the controls
  1135.         EnableControls(hdlg, TRUE);
  1136.  
  1137.         // Set the input focus to the Start button
  1138.         hCtl = GetDlgItem(hdlg, IDOK);
  1139.         SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hCtl, (LPARAM)TRUE);
  1140.     }
  1141.     else
  1142.     {
  1143.         // Copying was interupted so the dialog needs to be reset via Re-Set
  1144.         // button.  So disable the Cancel button and enable the reset button
  1145.         // and give the focus to Re-Set Button.
  1146.         // Do not enable the controls until the Re-Set button is pushed.
  1147.         // Also the status of the dialog is set to Re-Set.
  1148.  
  1149.         hCtl = GetDlgItem(hdlg, IDD_STOP);
  1150.         EnableWindow(hCtl, FALSE);
  1151.  
  1152.         hCtl = GetDlgItem(hdlg, IDD_RESET);
  1153.         EnableWindow(hCtl, TRUE);
  1154.         SendMessage(hdlg, WM_NEXTDLGCTL, (WPARAM)hCtl, (LPARAM)TRUE);
  1155.   
  1156.         hCtl = GetDlgItem(hdlg, IDD_STATUSBAR);
  1157.         SendMessage(hCtl, SB_SETTEXT, (WPARAM)3|0, (LPARAM)(LPSTR)"Re-Set!");
  1158.     }
  1159.  
  1160.     // Set the copy flag to indicate end of copying.
  1161.     fIsCopyState = FALSE;
  1162.  
  1163.     KillTimer(hdlg, TimerID);
  1164.  
  1165.     return TRUE;
  1166. }
  1167.