home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sdktools / winnt / dlgedit / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-05  |  25.7 KB  |  1,014 lines
  1.  
  2. /******************************************************************************\
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. \******************************************************************************/
  11.  
  12. /****************************** Module Header *******************************
  13. * Module Name: util.c
  14. *
  15. * Contains miscellaneous utility functions for dlgedit.
  16. *
  17. * Functions:
  18. *   MyAlloc()
  19. *   MyRealloc()
  20. *   MyFree()
  21. *   IsValue()
  22. *   HasBlanks()
  23. *   valtoi()
  24. *   axtoi()
  25. *   Myitoa()
  26. *   itoax()
  27. *   IsUniqueID()
  28. *   NextID()
  29. *   Message()
  30. *   ClientToScreenRect()
  31. *   ScreenToClientRect()
  32. *   DUToWinPoint()
  33. *   WinToDUPoint()
  34. *   DUToWinRect()
  35. *   WinToDURect()
  36. *   MapDlgClientPoint()
  37. *   MapWindowPoint()
  38. *   MyMapWindowRect()
  39. *   GetChildRect()
  40. *   CenterWindow()
  41. *   FitRectToScreen()
  42. *   ids()
  43. *   PixelsToPointSize()
  44. *   PointSizeToPixels()
  45. *
  46. * Comments:
  47. *
  48. ****************************************************************************/
  49.  
  50. #include "dlgedit.h"
  51. #include "dlgfuncs.h"
  52. #include "dlgextrn.h"
  53.  
  54. #include <stdarg.h>
  55. #include <ctype.h>
  56.  
  57.  
  58. #define CBOVERHEAD      (sizeof(INT)+sizeof(INT)+sizeof(INT))
  59. #define MEMSIGHEAD      0x1234
  60. #define MEMSIGTAIL      0x5678
  61.  
  62.  
  63. STATICFN BOOL IDUsedByCtrl(INT id);
  64.  
  65.  
  66.  
  67. /****************************************************************************
  68. * MyAlloc
  69. *
  70. * Does a local alloc.
  71. * 
  72. * Arguments:
  73. *   INT cbAlloc - number of bytes to allocate.
  74. *
  75. * Returns:
  76. *
  77. * A pointer to the memory if succesful; otherwise, NULL.
  78. *
  79. ****************************************************************************/
  80.  
  81. VOID *MyAlloc(
  82.     INT cbAlloc)
  83. {
  84.     register HANDLE hMem;
  85.  
  86.     if (hMem = LocalAlloc(LMEM_FIXED, cbAlloc)) {
  87.         return (VOID *)hMem;
  88.     }
  89.     else {
  90.         MessageBeep(0);
  91.         Message(MSG_OUTOFMEMORY);
  92.  
  93.         return NULL;
  94.     }
  95. }
  96.  
  97.  
  98. /****************************************************************************
  99. * MyRealloc
  100. *
  101. * reallocates memory and returns a pointer to the memory block.
  102. *
  103. ****************************************************************************/
  104.  
  105. VOID *MyRealloc(
  106.     VOID *npMem,
  107.     INT cbNewAlloc)
  108. {
  109.     npMem = (VOID *)LocalReAlloc((HANDLE)npMem, cbNewAlloc, LMEM_MOVEABLE);
  110.  
  111.     if (!npMem) {
  112.         MessageBeep(0);
  113.         Message(MSG_OUTOFMEMORY);
  114.  
  115.         return NULL;
  116.     }
  117.  
  118.     return npMem;
  119. }
  120.  
  121. /****************************************************************************
  122. * MyFree
  123. *
  124. * Frees the specified memory.
  125. *
  126. ****************************************************************************/
  127.  
  128. VOID *MyFree(
  129.     VOID *npMem)
  130. {
  131.     if (LocalFree((HANDLE)npMem)) {
  132.         MessageBeep(0);
  133.         Message(MSG_MEMERROR);
  134.  
  135.         return npMem;
  136.     }
  137.  
  138.     return NULL;
  139. }
  140.  
  141.  
  142.  
  143. /************************************************************************
  144. * IsValue
  145. *
  146. * This function tells you if the string you give it represents a
  147. * valid value or not.  For this purpose, a valid value can only
  148. * have the ascii characters from '0' to '9' with possibly the
  149. * first character being '-'.  Or be a Hex Number, with 0x preceeding
  150. * it.
  151. *
  152. * Arguments:
  153. *     LPTSTR pszValue  = The string to test.
  154. *
  155. * Returns:
  156. *     (0 == 0) if szValue represents a value.
  157. *     (c == 0) if szValue does not represent a value where c is
  158. *               non-zero.
  159. *
  160. *
  161. ************************************************************************/
  162.  
  163. BOOL IsValue(
  164.     LPTSTR pszValue)
  165. {
  166.     INT i;
  167.  
  168.     if (pszValue[0] == CHAR_0 &&
  169.             (pszValue[1] == CHAR_X || pszValue[1] == CHAR_CAP_X)) {
  170.         for (i = 2; iswxdigit(pszValue[i]); i++)
  171.             ;
  172.     }
  173.     else {
  174.         for (i = 0; iswdigit(pszValue[i]) ||
  175.                 (i == 0 && pszValue[i] == CHAR_MINUS); i++)
  176.             ;
  177.     }
  178.  
  179.     return (pszValue[i] == 0);
  180. }
  181.  
  182.  
  183.  
  184. /************************************************************************
  185. * HasBlanks
  186. *
  187. * This function returns TRUE if the given string has imbedded
  188. * blanks in it.
  189. *
  190. * Arguments:
  191. *   LPTSTR psz - String to check.
  192. *
  193. *
  194. ************************************************************************/
  195.  
  196. BOOL HasBlanks(
  197.     LPTSTR psz)
  198. {
  199.     while (*psz)
  200.         if (*psz == CHAR_SPACE)
  201.             return TRUE;
  202.         else
  203.             psz = CharNext(psz);
  204.  
  205.     return FALSE;
  206. }
  207.  
  208.  
  209.  
  210. /************************************************************************
  211. * valtoi
  212. *
  213. * Takes a string and returns its integer representation.
  214. * This function handles both hex ("0x1234") and decimal ("1234")
  215. * strings transparently.
  216. *
  217. * Arguments:
  218. *   LPTSTR pszValue = The string to convert.
  219. *
  220. *
  221. ************************************************************************/
  222.  
  223. INT valtoi(
  224.     LPTSTR pszValue)
  225. {
  226.     return (pszValue[0] == CHAR_0 &&
  227.             (pszValue[1] == CHAR_CAP_X || pszValue[1] == CHAR_X)) ?
  228.             axtoi(&pszValue[2]) : awtoi(pszValue);
  229. }
  230.  
  231.  
  232.  
  233. /************************************************************************
  234. * axtoi
  235. *
  236. * This function converts a null terminated ascii string for a
  237. * hex number to its integer value.  Should just be the number
  238. * with no preceeding "0x" or trailing "H".  Garbage will result
  239. * if there are non-hex digits in the string.  Hex digits are:
  240. * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, a, b, c, d, e, f.
  241. * Non-hex digits will be treated like '0'.
  242. *
  243. * Arguments:
  244. *     LPTSTR pch  = The null terminated hex string.
  245. *
  246. * Returns:
  247. *     The integer value represented by the given ascii string.
  248. *
  249. ************************************************************************/
  250.  
  251. INT axtoi(
  252.     LPTSTR pch)
  253. {
  254.     register TCHAR ch;
  255.     register INT n = 0;
  256.  
  257.     while((ch = *pch++) != 0) {
  258.         if (iswdigit(ch))
  259.             ch -= CHAR_0;
  260.         else if (ch >= CHAR_CAP_A && ch <= CHAR_CAP_F)
  261.             ch += (TCHAR)(10 - CHAR_CAP_A);
  262.         else if (ch >= CHAR_A && ch <= CHAR_F)
  263.             ch += (TCHAR)(10 - CHAR_A);
  264.         else
  265.             ch = (TCHAR)0;
  266.  
  267.         n = 16 * n + ch;
  268.     }
  269.  
  270.     return n;
  271. }
  272.  
  273.  
  274.  
  275. /************************************************************************
  276. * Myitoa
  277. *
  278. * This function converts a word to an ascii string.  It builds either
  279. * a decimal string or a hex string, based on whether Hex Mode is on
  280. * when it is called.
  281. *
  282. * Arguments:
  283. *   INT n      - The number to convert.
  284. *   LPTSTR psz - The buffer to put the string in, should have at least
  285. *                17 bytes to take the string.
  286. *
  287. ************************************************************************/
  288.  
  289. VOID Myitoa(
  290.     INT n,
  291.     LPTSTR psz)
  292. {
  293.     if (gfHexMode)
  294.         itoax(n, psz);
  295.     else
  296.         itoaw(n, psz, 10);
  297. }
  298.  
  299.  
  300.  
  301. /************************************************************************
  302. * itoax
  303. *
  304. * This function converts an int, 'n', to an ascii string
  305. * representing it as a 4 digit hex number with "0x" preceeding it.
  306. *
  307. * Arguments:
  308. *   INT n          = The number to convert.
  309. *   LPTSTR pszBuff = The buffer to put the string in, must
  310. *                    be at least 7 characters long to take the string.
  311. *
  312. *
  313. ************************************************************************/
  314.  
  315. VOID itoax(
  316.     INT n,
  317.     LPTSTR pszBuff)
  318. {
  319.     INT i;
  320.     INT j;
  321.  
  322.     pszBuff[0] = CHAR_0;
  323.     pszBuff[1] = CHAR_X;
  324.  
  325.     for (i = 5; i > 1; i--) {
  326.         j = n & 15;
  327.  
  328.         if (j > 9)
  329.             pszBuff[i] = (TCHAR)(j + (CHAR_A - 10));
  330.         else
  331.             pszBuff[i] = (TCHAR)(j + CHAR_0);
  332.  
  333.         n = n >> 4;
  334.     }
  335.  
  336.     pszBuff[6] = CHAR_NULL;
  337. }
  338.  
  339.  
  340.  
  341. /************************************************************************
  342. * NextID
  343. *
  344. * This function returns the next available id.
  345. *
  346. * For dialogs, it starts at 100 and increments by 100.  It will not
  347. * return a value until it finds one that begins a range that is
  348. * not used by any control in any of the dialogs in the res list.
  349. * In other words, it is guaranteed that the number returned and
  350. * the range of the next 99 numbers are not used by any control in
  351. * any dialog in the current res file.
  352. *
  353. * When returning a new id for a control, it usually starts at the
  354. * dialog base, but if there are any controls, it starts at one higher
  355. * than the id of the last control in the dialog that does not have
  356. * one of the special-cased ids (the unused id, IDOK or IDCANCEL).
  357. * It will find the first available id above this.
  358. *
  359. * When returning a default id for a new label, it starts at the dialog
  360. * base (or 100 if there is not a dialog being edited) and starts
  361. * searching for the first available one.  It guarantees that the
  362. * id returned is not used by any control in the current dialog, or
  363. * any other label, or any control in the entire resource list.
  364. *
  365. * Arguments:
  366. *   INT idType      - The type of id desired:
  367. *                     NEXTID_DIALOG  = ID for a new dialog.
  368. *                     NEXTID_CONTROL = ID for a new control.
  369. *                     NEXTID_LABEL   = ID for a new label.
  370. *   NPLABEL plHead  - The current label list to check for conflicts with.
  371. *   INT idExclude   - An id that you specifically want to skip over.
  372. *                     Set to zero if you don't care.
  373. *
  374. * Returns:
  375. *     The "next" unused id value.
  376. *
  377. *
  378. ************************************************************************/
  379.  
  380. INT NextID(
  381.     INT idType,
  382.     NPLABEL plHead,
  383.     INT idExclude)
  384. {
  385.     INT id;
  386.  
  387.     if (idType == NEXTID_CONTROL) {
  388.         /*
  389.          * Start at the base from the dialog plus one.  It is
  390.          * assumed that this routine will not be called for an
  391.          * id for a control if there is not a dialog being
  392.          * edited first.
  393.          */
  394.         id = gcd.npc->id + 1;
  395.  
  396.         /*
  397.          * Keep looping until an unused id is found.
  398.          */
  399.         while (!IsUniqueID(id) || FindID(id, plHead) || id == idExclude)
  400.             id++;
  401.     }
  402.     else if (idType == NEXTID_DIALOG) {
  403.         /*
  404.          * Start at 100.
  405.          */
  406.         id = 100;
  407.  
  408.         /*
  409.          * Keep looping by hundreds until an unused id is found.
  410.          */
  411.         while (!IsUniqueID(id) || FindID(id, plHead) || id == idExclude)
  412.             id += 100;
  413.     }
  414.     else {
  415.         /*
  416.          * We are looking for a default id for a new label.  Start
  417.          * at the dialog base, if there is a dialog being edited.
  418.          */
  419.         if (gfEditingDlg)
  420.             id = gcd.npc->id + 1;
  421.         else
  422.             id = 100;
  423.  
  424.         /*
  425.          * Keep looping until an unused id is found.  The id should
  426.          * not be used by any control in the current dialog, any
  427.          * other label already, or any control in the res file.
  428.          */
  429.         while (FindID(id, plHead) || FindIDInRes(id) || id == idExclude)
  430.             id++;
  431.     }
  432.  
  433.     /*
  434.      * We found an unused one.  Return it.
  435.      */
  436.     return id;
  437. }
  438.  
  439.  
  440.  
  441. /************************************************************************
  442. * IDUsedByCtrl
  443. *
  444. * This function returns TRUE if the given ID is used by any control
  445. * in the current dialog.  This also counts the text field of W_ICON
  446. * controls, if they are ordinals.
  447. *
  448. * Arguments:
  449. *   INT id = The ID to look for.
  450. *
  451. * Returns:
  452. *   TRUE if the id is used, FALSE if not.
  453. *
  454. *
  455. ************************************************************************/
  456.  
  457. STATICFN BOOL IDUsedByCtrl(
  458.     INT id)
  459. {
  460.     register NPCTYPE npc;
  461.  
  462.     for (npc = npcHead; npc; npc = npc->npcNext) {
  463.         if (npc->id == id ||
  464.                 (npc->pwcd->iType == W_ICON &&
  465.                 npc->text &&
  466.                 IsOrd(npc->text) &&
  467.                 id == (INT)OrdID(npc->text)))
  468.             return TRUE;
  469.     }
  470.  
  471.     return FALSE;
  472. }
  473.  
  474.  
  475.  
  476. /************************************************************************
  477. * IsUniqueID
  478. *
  479. * This function returns TRUE if the given id is unique.  A unique
  480. * id is either the special "unused" id value, or it is an id that
  481. * is not already assigned to any other control in the current dialog
  482. * and it is not assigned to any other dialog in the current res list.
  483. *
  484. * Note that this routine does NOT look for duplicates in the include
  485. * file of this id, only for ids that have been used by other controls
  486. * or dialogs already.
  487. *
  488. * Arguments:
  489. *   INT id = The id to verify is unique.
  490. *
  491. * Returns:
  492. *   TRUE if the id is "unique", FALSE if it is not.
  493. *
  494. *
  495. ************************************************************************/
  496.  
  497. BOOL IsUniqueID(
  498.     INT id)
  499. {
  500.     ORDINAL ord;
  501.  
  502.     /*
  503.      * If the id is the special unused id, it is considered unique.
  504.      */
  505.     if (id == IDUNUSED)
  506.         return TRUE;
  507.  
  508.     /*
  509.      * Not unique if another control in the dialog has the same id.
  510.      */
  511.     if (IDUsedByCtrl(id))
  512.         return FALSE;
  513.  
  514.     /*
  515.      * Not unique if another dialog has the same id.
  516.      */
  517.     WriteOrd(&ord, id);
  518.     if (FindDialog((LPTSTR)&ord))
  519.         return FALSE;
  520.  
  521.     return TRUE;
  522. }
  523.  
  524.  
  525.  
  526. /************************************************************************
  527. * Message
  528. *
  529. * This function puts up a message box with a string indexed by idMsg.
  530. *
  531. * Returns:
  532. *     What MessageBox returns.
  533. *
  534. ************************************************************************/
  535.  
  536. INT Message(
  537.     INT idMsg,
  538.     ...)
  539. {
  540.     va_list marker;
  541.     INT RetCode;
  542.     TCHAR szT[CCHTEXTMAX];
  543.     BOOL fDisabledSave;
  544.  
  545.     va_start(marker, idMsg);
  546.     wvsprintf(szT, ids(gamdMessages[idMsg].ids), marker);
  547.  
  548.     fDisabledSave = gfDisabled;
  549.     gfDisabled = TRUE;
  550.     RetCode = MessageBox(NULL, szT, ids(IDS_DLGEDIT),
  551.             (WORD)(gamdMessages[idMsg].fMessageBox | MB_TASKMODAL));
  552.     gfDisabled = fDisabledSave;
  553.  
  554.     va_end(marker);
  555.  
  556.     return RetCode;
  557. }
  558.  
  559.  
  560.  
  561. /************************************************************************
  562. * ClientToScreenRect
  563. *
  564. * This function converts the coordinates in a rectangle from points
  565. * relative to the client area into points that are relative to the
  566. * screen.
  567. *
  568. * Arguments:
  569. *   HWND hwnd - Window handle for the conversion.
  570. *   PRECT prc - Pointer to the rectangle to convert.
  571. *
  572. *
  573. ************************************************************************/
  574.  
  575. VOID ClientToScreenRect(
  576.     HWND hwnd,
  577.     PRECT prc)
  578. {
  579.     ClientToScreen(hwnd, (PPOINT)prc);
  580.     ClientToScreen(hwnd, ((PPOINT)prc) + 1);
  581. }
  582.  
  583.  
  584.  
  585. /************************************************************************
  586. * ScreenToClientRect
  587. *
  588. * This function converts the coordinates in a rectangle from points
  589. * relative to the screen into points that are relative to the given
  590. * window's client area.
  591. *
  592. * Arguments:
  593. *   HWND hwnd - Window handle for the conversion.
  594. *   PRECT prc - Pointer to the rectangle to convert.
  595. *
  596. *
  597. ************************************************************************/
  598.  
  599. VOID ScreenToClientRect(
  600.     HWND hwnd,
  601.     PRECT prc)
  602. {
  603.     ScreenToClient(hwnd, (PPOINT)prc);
  604.     ScreenToClient(hwnd, ((PPOINT)prc) + 1);
  605. }
  606.  
  607.  
  608.  
  609. /************************************************************************
  610. * DUToWinPoint
  611. *
  612. * This function converts the coordinates in the given point from
  613. * dialog units (DU's) to window units for the current dialog.
  614. *
  615. * Arguments:
  616. *   PPOINT ppt - Pointer to the point to convert.
  617. *
  618. *
  619. ************************************************************************/
  620.  
  621. VOID DUToWinPoint(
  622.     PPOINT ppt)
  623. {
  624.     ppt->x = MulDiv(ppt->x, gcd.cxChar, 4);
  625.     ppt->y = MulDiv(ppt->y, gcd.cyChar, 8);
  626. }
  627.  
  628.  
  629.  
  630. /************************************************************************
  631. * WinToDUPoint
  632. *
  633. * This function converts the coordinates in the given point from
  634. * window points to dialog units (DU's) for the current dialog.
  635. *
  636. * Arguments:
  637. *   PPOINT ppt - Pointer to the point to convert.
  638. *
  639. *
  640. ************************************************************************/
  641.  
  642. VOID WinToDUPoint(
  643.     PPOINT ppt)
  644. {
  645.     ppt->x = MulDiv(ppt->x, 4, gcd.cxChar);
  646.     ppt->y = MulDiv(ppt->y, 8, gcd.cyChar);
  647. }
  648.  
  649.  
  650.  
  651. /************************************************************************
  652. * DUToWinRect
  653. *
  654. * This function converts the coordinates in a rectangle from
  655. * dialog units for the current dialog to window units.
  656. *
  657. * Arguments:
  658. *   PRECT prc - Pointer to the rectangle to convert.
  659. *
  660. *
  661. ************************************************************************/
  662.  
  663. VOID DUToWinRect(
  664.     PRECT prc)
  665. {
  666.     DUToWinPoint((PPOINT)prc);
  667.     DUToWinPoint(((PPOINT)prc) + 1);
  668. }
  669.  
  670.  
  671.  
  672. /************************************************************************
  673. * WinToDURect
  674. *
  675. * This function converts the coordinates in a rectangle from
  676. * window units to dialog units for the current dialog.
  677. *
  678. * Arguments:
  679. *   PRECT prc - Pointer to the rectangle to convert.
  680. *
  681. *
  682. ************************************************************************/
  683.  
  684. VOID WinToDURect(
  685.     PRECT prc)
  686. {
  687.     WinToDUPoint((PPOINT)prc);
  688.     WinToDUPoint(((PPOINT)prc) + 1);
  689. }
  690.  
  691.  
  692.  
  693. /************************************************************************
  694. * MapDlgClientPoint
  695. *
  696. * This function converts client points to be relative to the window
  697. * origin instead, or the other way around.  If fFromClient is TRUE,
  698. * the point is considered to be relative to the client origin in
  699. * the dialog, and will be converted to a point relative to the
  700. * window origin instead.
  701. *
  702. * If fFromClient is FALSE, the point is considered to be relative
  703. * to the window origin, and will be mapped to a point that is
  704. * relative to the client origin.
  705. *
  706. * This function assumes that the global grcDlgClient has been
  707. * previously calculated.  It should only be called to map points
  708. * for the current dialog being edited (for which grcDlgClient has
  709. * been calculated).
  710. *
  711. * Arguments:
  712. *   PPOINT ppt       - Pointer to the point to convert.
  713. *   BOOL fFromClient - TRUE if the point is relative to the client origin.
  714. *
  715. *
  716. ************************************************************************/
  717.  
  718. VOID MapDlgClientPoint(
  719.     PPOINT ppt,
  720.     BOOL fFromClient)
  721. {
  722.     if (fFromClient) {
  723.         ppt->x += grcDlgClient.left;
  724.         ppt->y += grcDlgClient.top;
  725.     }
  726.     else {
  727.         ppt->x -= grcDlgClient.left;
  728.         ppt->y -= grcDlgClient.top;
  729.     }
  730. }
  731.  
  732.  
  733.  
  734. /************************************************************************
  735. * MapWindowPoint
  736. *
  737. * This function maps a point from one window to another.  The point
  738. * given is in window coordinates (not client coordinates) and is
  739. * mapped so that it is relative to the destination window.
  740. *
  741. * Arguments:
  742. *   HWND hwndFrom   - Source window.
  743. *   HWND hwndTo     - Destination window.
  744. *   PPOINT ppt      - Pointer to the point to convert.
  745. *
  746. * Comments:
  747. * In Win 3.1 (and NT) the MapWindowPoints call can be used and this one can be removed.
  748. * It is only needed here for compatibility with Win 3.0.
  749. *
  750. ************************************************************************/
  751.  
  752. VOID MapWindowPoint(
  753.     HWND hwndFrom,
  754.     HWND hwndTo,
  755.     PPOINT ppt)
  756. {
  757.     RECT rcFrom;
  758.     RECT rcTo;
  759.  
  760.     GetWindowRect(hwndFrom, &rcFrom);
  761.     GetWindowRect(hwndTo, &rcTo);
  762.  
  763.     ppt->x += rcFrom.left - rcTo.left;
  764.     ppt->y += rcFrom.top - rcTo.top;
  765. }
  766.  
  767.  
  768.  
  769. /************************************************************************
  770. * MyMapWindowRect
  771. *
  772. * This function maps a rectangle from one window to another.  The rectangle
  773. * given is in window coordinates (not client coordinates) and is
  774. * mapped so that it is relative to the destination window.
  775. *
  776. * Arguments:
  777. *   HWND hwndFrom   - Source window.
  778. *   HWND hwndTo     - Destination window.
  779. *   PRECT prc       - Pointer to the rectangle to convert.
  780. *
  781. * Comments:
  782. * In Win 3.1 (and NT) the MapWindowRect call can be used and this one can be removed.
  783. * It is only needed here for compatibility with Win 3.0.
  784. ************************************************************************/
  785.  
  786. VOID MyMapWindowRect(
  787.     HWND hwndFrom,
  788.     HWND hwndTo,
  789.     PRECT prc)
  790. {
  791.     RECT rcFrom;
  792.     RECT rcTo;
  793.  
  794.     GetWindowRect(hwndFrom, &rcFrom);
  795.     GetWindowRect(hwndTo, &rcTo);
  796.  
  797.     OffsetRect(prc, rcFrom.left - rcTo.left, rcFrom.top - rcTo.top);
  798. }
  799.  
  800.  
  801.  
  802. /************************************************************************
  803. * GetChildRect
  804. *
  805. * This function returns the client rectangle for a given child control,
  806. * mapped to its parent window.
  807. *
  808. * Arguments:
  809. *   HWND hwndChild - Child window.
  810. *   PRECT prc      - Where to return the rectangle.
  811. *
  812. ************************************************************************/
  813.  
  814. VOID GetChildRect(
  815.     HWND hwndChild,
  816.     PRECT prc)
  817. {
  818.     HWND hwndParent;
  819.  
  820.     hwndParent = GetParent(hwndChild);
  821.     GetClientRect(hwndChild, prc);
  822.     ClientToScreenRect(hwndChild, prc);
  823.     ScreenToClientRect(hwndParent, prc);
  824. }
  825.  
  826.  
  827.  
  828. /************************************************************************
  829. * CenterWindow
  830. *
  831. * This function centers the given window over its owner.  It ensures
  832. * that the window is entirely within the visible screen, however.
  833. * If the window does not have an owner, it is centered over the
  834. * desktop.
  835. *
  836. * Arguments:
  837. *   HWND hwnd - The window to center.
  838. *
  839. ************************************************************************/
  840.  
  841. VOID CenterWindow(
  842.     HWND hwnd)
  843. {
  844.     RECT rc;
  845.     RECT rcOwner;
  846.     RECT rcCenter;
  847.     HWND hwndOwner;
  848.  
  849.     GetWindowRect(hwnd, &rc);
  850.  
  851.     if (!(hwndOwner = GetWindow(hwnd, GW_OWNER)))
  852.         hwndOwner = GetDesktopWindow();
  853.  
  854.     GetWindowRect(hwndOwner, &rcOwner);
  855.  
  856.     /*
  857.      *  Calculate the starting x,y for the new
  858.      *  window so that it would be centered.
  859.      */
  860.     rcCenter.left = rcOwner.left +
  861.             (((rcOwner.right - rcOwner.left) -
  862.             (rc.right - rc.left))
  863.             / 2);
  864.  
  865.     rcCenter.top = rcOwner.top +
  866.             (((rcOwner.bottom - rcOwner.top) -
  867.             (rc.bottom - rc.top))
  868.             / 2);
  869.  
  870.     rcCenter.right = rcCenter.left + (rc.right - rc.left);
  871.     rcCenter.bottom = rcCenter.top + (rc.bottom - rc.top);
  872.  
  873.     FitRectToScreen(&rcCenter);
  874.  
  875.     SetWindowPos(hwnd, NULL, rcCenter.left, rcCenter.top, 0, 0,
  876.             SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
  877. }
  878.  
  879.  
  880.  
  881. /************************************************************************
  882. * FitRectToScreen
  883. *
  884. * This function ensures that the given rectangle is entirely within
  885. * the visible screen, adjusting it if necessary.
  886. *
  887. * Arguments:
  888. *   PRECT prc - The rectangle.
  889. *
  890. ************************************************************************/
  891.  
  892. VOID FitRectToScreen(
  893.     PRECT prc)
  894. {
  895.     INT cxScreen;
  896.     INT cyScreen;
  897.     INT delta;
  898.  
  899.     cxScreen = GetSystemMetrics(SM_CXSCREEN);
  900.     cyScreen = GetSystemMetrics(SM_CYSCREEN);
  901.  
  902.     if (prc->right > cxScreen) {
  903.         delta = prc->right - prc->left;
  904.         prc->right = cxScreen;
  905.         prc->left = prc->right - delta;
  906.     }
  907.  
  908.     if (prc->left < 0) {
  909.         delta = prc->right - prc->left;
  910.         prc->left = 0;
  911.         prc->right = prc->left + delta;
  912.     }
  913.  
  914.     if (prc->bottom > cyScreen) {
  915.         delta = prc->bottom - prc->top;
  916.         prc->bottom = cyScreen;
  917.         prc->top = prc->bottom - delta;
  918.     }
  919.  
  920.     if (prc->top < 0) {
  921.         delta = prc->bottom - prc->top;
  922.         prc->top = 0;
  923.         prc->bottom = prc->top + delta;
  924.     }
  925. }
  926.  
  927.  
  928.  
  929. /************************************************************************
  930. * ids
  931. *
  932. * This function will return a string, given the string id.  If this is
  933. * the first time that the string has been retrieved, memory will be
  934. * allocated for it and it will be loaded.  After it is loaded once, it
  935. * is then cached in a LPTSTR array and is available for later without
  936. * having to load it again.
  937. *
  938. * Arguments:
  939. *   UINT idString - String ID of the string to retrieve.
  940. *
  941. ************************************************************************/
  942.  
  943. LPTSTR ids(
  944.     UINT idString)
  945. {
  946.     static LPTSTR apsz[CSTRINGS];       // String resource array cache.
  947.     LPTSTR psz;
  948.     INT cch;
  949.  
  950.     if (apsz[idString])
  951.         return apsz[idString];
  952.  
  953.     if (!(psz = MyAlloc(CCHTEXTMAX * sizeof(TCHAR))))
  954.         return szEmpty;
  955.  
  956.     if (!(cch = LoadString(ghInst, idString, psz, CCHTEXTMAX))) {
  957.         MyFree(psz);
  958.         return szEmpty;
  959.     }
  960.  
  961.     apsz[idString] = psz = MyRealloc(psz, (cch + 1) * sizeof(TCHAR));
  962.  
  963.     return (psz ? psz : szEmpty);
  964. }
  965.  
  966.  
  967.  
  968. /************************************************************************
  969. * PixelsToPointSize
  970. *
  971. * This function takes a font height in pixels and converts it to
  972. * the equivalent point size.  Note that the pixel height of a font
  973. * is actually the tmHeight field of the TEXTMETRIC structure minus
  974. * the tmInternalLeading value.
  975. *
  976. * This function relies on the global gcyPixelsPerInch having been
  977. * set before it is called.
  978. *
  979. * Arguments:
  980. *   INT nPixels - Pixel size to convert to point size.
  981. *
  982. ************************************************************************/
  983.  
  984. INT PixelsToPointSize(
  985.     INT nPixels)
  986. {
  987.     return MulDiv(nPixels, 72, gcyPixelsPerInch);
  988. }
  989.  
  990.  
  991.  
  992. /************************************************************************
  993. * PointSizeToPixels
  994. *
  995. * This function takes a given point size and converts it to the
  996. * equivalent pixel text height.  This value can be placed in
  997. * the TEXTMETRIC structure's tmHeight field if it is made negative
  998. * first.  This will cause a CreateFont call to automatically
  999. * subtract the internal leading value before creating the font.
  1000. *
  1001. * This function relies on the global gcyPixelsPerInch having been
  1002. * set before it is called.
  1003. *
  1004. * Arguments:
  1005. *   INT nPointSize - Point size to convert to pixels.
  1006. *
  1007. ************************************************************************/
  1008.  
  1009. INT PointSizeToPixels(
  1010.     INT nPointSize)
  1011. {
  1012.     return MulDiv(nPointSize, gcyPixelsPerInch, 72);
  1013. }
  1014.