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