![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to allfont.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ntfonts|
Return to allfont.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ntfonts |
1.1 ! root 1: /**************************************************************************\ ! 2: * allfont.c -- module to display the result of enumerating all fonts. ! 3: * Includes the window procedure and an initialization routine. ! 4: * ! 5: * There are actually two windows serviced by this module. One for the ! 6: * display fonts, one for the printer fonts. ! 7: * ! 8: * ! 9: * Data structure: ! 10: * Since we keep a modest amount of data for each possible font, and ! 11: * since the amount of this information is known only at run time, ! 12: * the main data structure used here is all allocated dynamically. ! 13: * parFonts points to an array of ARFONT structures. These structures ! 14: * store two int's and then three pointers to arrays of LOGFONT, ! 15: * TEXTMETRIC, and int's respectively. ! 16: * ! 17: * parFonts--> |--------------------| |--------------------| ! 18: * | nFonts (Family0) | | nFonts (Family1) | ! 19: * | cySpace | | cySpace | ... ! 20: * | hdc | | hdc | ! 21: * |--------------------| |--------------------| ! 22: * | lf | tm | Type | | lf | tm | Type | ! 23: * |--------------------| |--------------------| ! 24: * | | | | | | ! 25: * | | | | | | ! 26: * V V V V V V ! 27: * |----| |------| |----| |----| |------| |----| ! 28: * |LOG | |TEXT | |Type| |LOG | |TEXT | |Type| ! 29: * |FONT| |METRIC| | | |FONT| |METRIC| | | ! 30: * |0,0 | |0,0 | |0,0 | |1,0 | |1,0 | |1,0 | ! 31: * |----| |------| |----| |----| |------| |----| ! 32: * |LOG | |TEXT | |Type| |LOG | |TEXT | |Type| ! 33: * |FONT| |METRIC| | | |FONT| |METRIC| | | ! 34: * |0,1 | |0,1 | |0,1 | |1,1 | |1,1 | |1,1 | ! 35: * |----| |------| |----| |----| |------| |----| ! 36: * ! 37: * ... ... ... ... ... ... ! 38: * ! 39: * |----| |------| |----| ! 40: * |LOG | |TEXT | |Type| ! 41: * |FONT| |METRIC| | | |----| |------| |----| ! 42: * |0, | |0, | |0, | |LOG | |TEXT | |Type| ! 43: * |nFon| |nFonts| |nFon| |FONT| |METRIC| | | ! 44: * |----| |------| |----| |1, | |1, | |1, | ! 45: * |nFon| |nFonts| |nFon| ! 46: * |----| |------| |----| ! 47: * ! 48: * ! 49: * So, to get the FontType of the 4th font within the 2nd family use: ! 50: * parFonts[1].Type[3] ! 51: * ! 52: * There is one final ARFONT structure which has no linked lists atttached, ! 53: * but has a blank HDC as padding on the far right of the window. ! 54: * ! 55: * The pointer to the array of ARFONT structures is stored in the ! 56: * GWL_PARFONTS extra bytes for each window. The number of face names ! 57: * for each window is stored in the GWLU_NFACES extra bytes. ! 58: * ! 59: \**************************************************************************/ ! 60: ! 61: #include <windows.h> ! 62: #include <string.h> ! 63: #include "ntfonts.h" ! 64: ! 65: ! 66: typedef struct tagArFonts{ ! 67: int nFonts; ! 68: int cySpace; ! 69: HDC hdc; ! 70: LOGFONT *lf; ! 71: TEXTMETRIC *tm; ! 72: int *Type; ! 73: } ARFONTS, *PARFONTS; ! 74: ! 75: ! 76: #define ALLFONTBORDER 10 ! 77: #define CXDEF 130 ! 78: #define BMSIZE 14 ! 79: ! 80: ! 81: /* user defined create messsage, sent to window once CreateWindow() returns */ ! 82: #define WMU_CREATE WM_USER + 10 ! 83: ! 84: #define GWLU_PARFONTS 0 ! 85: #define GWLU_NFACES 4 ! 86: ! 87: /* forward declare function prototypes. */ ! 88: HDC GetPrinterDC (VOID); ! 89: VOID DrawBitmapXY (HDC, HBITMAP, int, int); ! 90: ! 91: PARFONTS BuildFontList(HDC, LPINT); ! 92: VOID BuildBitmapStrips (HWND, LPRECT, PARFONTS, int); ! 93: ! 94: int APIENTRY MyEnumFaces(LPLOGFONT, LPTEXTMETRIC, DWORD, LPVOID); ! 95: int APIENTRY MyEnumCopy (LPLOGFONT, LPTEXTMETRIC, DWORD, LPVOID); ! 96: int APIENTRY MyEnumCount(LPLOGFONT, LPTEXTMETRIC, DWORD, LPINT); ! 97: ! 98: ! 99: ! 100: int initAllFont(HWND hwndMain) ! 101: { ! 102: WNDCLASS wc; ! 103: HDC hdc; ! 104: ! 105: wc.style = NULL; ! 106: wc.lpfnWndProc = (WNDPROC)AllFontsWndProc; ! 107: wc.cbClsExtra = 0; ! 108: wc.cbWndExtra = 8; ! 109: wc.hInstance = hInst; ! 110: wc.hIcon = NULL; ! 111: wc.hCursor = LoadCursor(NULL, IDC_CROSS); ! 112: wc.hbrBackground = GetStockObject(WHITE_BRUSH); ! 113: wc.lpszMenuName = NULL; ! 114: wc.lpszClassName = "AllFonts"; ! 115: ! 116: if (!RegisterClass(&wc)) return (FALSE); ! 117: ! 118: ! 119: /* create a window to show all of the display fonts, and send it ! 120: * the proper WMU_CREATE message with an HDC for the display. ! 121: */ ! 122: hwndDisplayFonts = CreateWindow( ! 123: "AllFonts", ! 124: NULL, ! 125: WS_CHILD | WS_CLIPSIBLINGS | WS_HSCROLL, ! 126: 0,0, ! 127: GetSystemMetrics (SM_CXFULLSCREEN), ! 128: GetSystemMetrics (SM_CYFULLSCREEN), ! 129: hwndMain, NULL, hInst, NULL); ! 130: ! 131: hdc = GetDC (hwndDisplayFonts); ! 132: SendMessage (hwndDisplayFonts, WMU_CREATE, (DWORD)hdc, 0); ! 133: ReleaseDC (hwndDisplayFonts, hdc); ! 134: ! 135: if (!hwndDisplayFonts) return (FALSE); ! 136: ! 137: ! 138: /* create a window to show all of the printer fonts, and send it ! 139: * the proper WMU_CREATE message with an HDC for the printer. ! 140: */ ! 141: hwndPrinterFonts = CreateWindow( ! 142: "AllFonts", ! 143: NULL, ! 144: WS_CHILD | WS_CLIPSIBLINGS | WS_HSCROLL, ! 145: 0,0, ! 146: GetSystemMetrics (SM_CXFULLSCREEN), ! 147: GetSystemMetrics (SM_CYFULLSCREEN), ! 148: hwndMain, NULL, hInst, NULL); ! 149: ! 150: hdc = GetPrinterDC (); ! 151: SendMessage (hwndPrinterFonts, WMU_CREATE, (DWORD)hdc, 0); ! 152: DeleteDC (hdc); ! 153: ! 154: if (!hwndPrinterFonts) return (FALSE); ! 155: ! 156: return TRUE; ! 157: } ! 158: ! 159: ! 160: ! 161: ! 162: ! 163: /**************************************************************************\ ! 164: * function: GetPrinterDC ! 165: * ! 166: * input parameters: none. ! 167: * ! 168: * Simply return an HDC for the default printer as specified in win.ini. ! 169: * Note that this HDC should be deleted later (DeleteDC). ! 170: \**************************************************************************/ ! 171: #define NCHAR MAX_PATH ! 172: ! 173: HDC GetPrinterDC () ! 174: { ! 175: char szPrinter[NCHAR]; ! 176: ! 177: char szDevice[NCHAR]; ! 178: char szDriver[NCHAR]; ! 179: char szOutput[NCHAR]; ! 180: ! 181: DEVMODE DevMode; ! 182: ! 183: GetProfileString ("windows", "device", "", szPrinter, NCHAR) ; ! 184: ! 185: strcpy (szDevice,strtok (szPrinter, "," )); ! 186: strcpy (szDriver,strtok (NULL, ", ")); ! 187: strcpy (szOutput,strtok (NULL, ", ")); ! 188: ! 189: return CreateDC (szDriver, szDevice, szOutput, &DevMode); ! 190: } ! 191: ! 192: ! 193: ! 194: ! 195: /**************************************************************************\ ! 196: * ! 197: * function: AllFontsWndProc ! 198: * ! 199: * input parameters: normal window procedure parameters. ! 200: * ! 201: * global variables: ! 202: * hwndMain - Main window. place to return focus. ! 203: * ! 204: * Create array of structures which contain, among other things, bitmap ! 205: * strips containing the face names of fonts. These strips are later ! 206: * scrolled back and forth as well as selected with the mouse. ! 207: * ! 208: \**************************************************************************/ ! 209: LRESULT AllFontsWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) ! 210: { ! 211: RECT rectClient; ! 212: int i,j; ! 213: int thumbpos; ! 214: int nStrips; ! 215: PARFONTS parFonts; ! 216: int nFaces; ! 217: ! 218: /* Get the pointer out of the userdata extra bytes. */ ! 219: parFonts = (PARFONTS) GetWindowLong (hwnd, GWLU_PARFONTS); ! 220: nFaces = GetWindowLong (hwnd, GWLU_NFACES); ! 221: ! 222: ! 223: switch (message) { ! 224: ! 225: ! 226: /**********************************************************************\ ! 227: * WMU_CREATE ! 228: * ! 229: * USER create message (sent after the window is created, before it ! 230: * is shown for the first time). Use this rather than WM_CREATE because ! 231: * we want to have control over the message parameters. ! 232: * ! 233: * wParam - HDC which we build the font list for. ! 234: * ! 235: * First build the 2d variable arrays of fonts (c.f. BuildFontList), then ! 236: * create the bitmap strips (stored in HDCs in ARFONT structures), ! 237: * Set the parFonts pointer into the extra bytes for use by other messages. ! 238: \**********************************************************************/ ! 239: case WMU_CREATE: { ! 240: int rightPos; ! 241: HDC hdc; ! 242: ! 243: hdc = (HDC) wParam; ! 244: ! 245: GetClientRect (hwnd, &rectClient); ! 246: InflateRect (&rectClient, 0, -ALLFONTBORDER); ! 247: ! 248: parFonts = BuildFontList (hdc, &nFaces); ! 249: ! 250: BuildBitmapStrips (hwnd, &rectClient, parFonts, nFaces); ! 251: ! 252: SetWindowLong (hwnd, GWLU_PARFONTS, (LONG) parFonts); ! 253: SetWindowLong (hwnd, GWLU_NFACES, nFaces); ! 254: ! 255: /* Compute the number of bitmap strips visible in the window. ! 256: * set the scroll bar range, ! 257: * or make it invisible if there are not enough fonts to justify. ! 258: */ ! 259: nStrips = (rectClient.right - rectClient.left) /CXDEF + 1; ! 260: if (nFaces > nStrips) { ! 261: rightPos = nFaces - nStrips + 1; ! 262: SetScrollRange (hwnd, SB_HORZ, 0, rightPos, FALSE); ! 263: } else { ! 264: SetScrollRange (hwnd, SB_HORZ, 0, 0, FALSE); ! 265: } ! 266: ! 267: } break; ! 268: ! 269: ! 270: /**********************************************************************\ ! 271: * WM_DESTROY ! 272: * ! 273: * Free up the memory allocated at create time. Notice that parFonts ! 274: * is allocated in BuildFontList, as are its subarrays. ! 275: \**********************************************************************/ ! 276: case WM_DESTROY: ! 277: for (i= 0; i<nFaces; i++) { ! 278: LocalFree ( LocalHandle ((LPSTR)parFonts[i].lf )); ! 279: LocalFree ( LocalHandle ((LPSTR)parFonts[i].tm )); ! 280: LocalFree ( LocalHandle ((LPSTR)parFonts[i].Type )); ! 281: DeleteDC (parFonts[i].hdc); ! 282: } ! 283: /* also get the final, blank one */ ! 284: DeleteDC (parFonts[nFaces].hdc); ! 285: ! 286: LocalFree ( LocalHandle ((LPSTR)parFonts)); ! 287: break; ! 288: ! 289: ! 290: /**********************************************************************\ ! 291: * WM_HSCROLL ! 292: * ! 293: * Slide the contents of the window back and forth. Notice that the ! 294: * scroll bar thumb position is important for painting and hit testing. ! 295: \**********************************************************************/ ! 296: case WM_HSCROLL: ! 297: /* compute number of strips for page scrolling. */ ! 298: GetClientRect (hwnd, &rectClient); ! 299: nStrips = (rectClient.right - rectClient.left) /CXDEF + 1; ! 300: ! 301: switch (LOWORD(wParam)){ ! 302: int OldPos, NewPos; ! 303: ! 304: case SB_LINEDOWN: ! 305: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 306: SetScrollPos (hwnd, SB_HORZ, (OldPos+1), TRUE); ! 307: NewPos = GetScrollPos (hwnd, SB_HORZ); ! 308: ScrollWindow (hwnd, (OldPos-NewPos)*CXDEF, 0, NULL, NULL); ! 309: break; ! 310: ! 311: case SB_PAGEDOWN: ! 312: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 313: SetScrollPos (hwnd, SB_HORZ, (OldPos+(nStrips-1)), TRUE); ! 314: NewPos = GetScrollPos (hwnd, SB_HORZ); ! 315: ScrollWindow (hwnd, (OldPos-NewPos)*CXDEF, 0, NULL, NULL); ! 316: break; ! 317: ! 318: case SB_LINEUP: ! 319: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 320: SetScrollPos (hwnd, SB_HORZ, (OldPos-1), TRUE); ! 321: NewPos = GetScrollPos (hwnd, SB_HORZ); ! 322: ScrollWindow (hwnd, (OldPos-NewPos)*CXDEF, 0, NULL, NULL); ! 323: break; ! 324: ! 325: case SB_PAGEUP: ! 326: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 327: SetScrollPos (hwnd, SB_HORZ, (OldPos-(nStrips-1)), TRUE); ! 328: NewPos = GetScrollPos (hwnd, SB_HORZ); ! 329: ScrollWindow (hwnd, (OldPos-NewPos)*CXDEF, 0, NULL, NULL); ! 330: break; ! 331: ! 332: case SB_THUMBPOSITION: ! 333: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 334: NewPos = HIWORD (wParam); ! 335: SetScrollPos (hwnd, SB_HORZ, NewPos, TRUE); ! 336: ScrollWindow (hwnd, (OldPos-NewPos)*CXDEF, 0, NULL, NULL); ! 337: break; ! 338: ! 339: } ! 340: break; ! 341: ! 342: ! 343: ! 344: /**********************************************************************\ ! 345: * WM_LBUTTONDOWN ! 346: * ! 347: * Hittest based on the mouse position. When finished, hide the window. ! 348: \**********************************************************************/ ! 349: case WM_LBUTTONDOWN: { ! 350: POINT mousePt; ! 351: ! 352: mousePt.x = LOWORD(lParam); ! 353: mousePt.y = HIWORD(lParam); ! 354: ! 355: mousePt.x -= 0; ! 356: mousePt.y -= ALLFONTBORDER; ! 357: ! 358: i = mousePt.x / CXDEF; ! 359: i += GetScrollPos (hwnd, SB_HORZ); ! 360: if (i < 0) i = 0; ! 361: if (i >= nFaces) i = (nFaces-1); ! 362: ! 363: j = mousePt.y / parFonts[i].cySpace; ! 364: if (j < 0) j = 0; ! 365: if (j >= parFonts[i].nFonts) j = (parFonts[i].nFonts-1); ! 366: ! 367: ShowWindow(hwnd, SW_HIDE); ! 368: UpdateWindow(hwndMain); ! 369: flyWinWin(hwndMain, hwnd, hwndDlgLF, 40); ! 370: SendMessage (hwndDlgLF, WMU_DEMOTOLF, 0,(LONG) &(parFonts[i].lf[j])); ! 371: ! 372: flyWinWin(hwndMain, hwnd, hwndDlgTM, 40); ! 373: SendMessage (hwndDlgTM, WMU_DEMOTOTM, 0,(LONG) &(parFonts[i].tm[j])); ! 374: SetFocus (hwndMain); ! 375: ! 376: }break; ! 377: ! 378: ! 379: /**********************************************************************\ ! 380: * WM_RBUTTONDOWN, WM_CHAR ! 381: * ! 382: * Put the window away without changing the LOGFONT or TEXTMETRIC dlgs. ! 383: \**********************************************************************/ ! 384: case WM_RBUTTONDOWN: ! 385: case WM_CHAR : ! 386: ShowWindow(hwnd, SW_HIDE); ! 387: SetFocus (hwndMain); ! 388: break; ! 389: ! 390: ! 391: /**********************************************************************\ ! 392: * WM_PAINT ! 393: * ! 394: * Using the HDCs stored in the parFonts array, blt enough strips of ! 395: * font family names to cover the window. ! 396: \**********************************************************************/ ! 397: case WM_PAINT : { ! 398: PAINTSTRUCT ps; ! 399: HDC hdc; ! 400: int iStrip; ! 401: ! 402: GetClientRect (hwnd, &rectClient); ! 403: hdc = BeginPaint(hwnd, &ps); ! 404: ! 405: ! 406: thumbpos = GetScrollPos (hwnd, SB_HORZ); ! 407: ! 408: nStrips = (rectClient.right - rectClient.left) /CXDEF + 1; ! 409: ! 410: for (iStrip= 0; iStrip<nStrips; iStrip++) ! 411: BitBlt (hdc, iStrip*CXDEF,0, ! 412: CXDEF, ! 413: (rectClient.bottom - rectClient.top), ! 414: parFonts[iStrip+thumbpos].hdc, 0,0, SRCCOPY); ! 415: ! 416: ! 417: EndPaint (hwnd, &ps); ! 418: } break; ! 419: ! 420: ! 421: default: ! 422: return (DefWindowProc(hwnd, message, wParam, lParam)); ! 423: } ! 424: return (NULL); ! 425: } ! 426: ! 427: ! 428: ! 429: ! 430: /**************************************************************************\ ! 431: * ! 432: * function: DrawBitmapXY() ! 433: * ! 434: * input parameters: HDC, HBITMAP, ! 435: * X, Y - destination position. (get width and height from hbitmap) ! 436: * ! 437: * Draw the bitmap into the hdc. Source rectangle computed to include the ! 438: * whole bitmap. ! 439: * ! 440: * global variables: none. ! 441: * ! 442: \**************************************************************************/ ! 443: VOID DrawBitmapXY (HDC hdc, HBITMAP hbm, int x, int y) ! 444: { ! 445: BOOL f; ! 446: HDC hdcBits; ! 447: BITMAP bm; ! 448: ! 449: hdcBits = CreateCompatibleDC(hdc); ! 450: GetObject (hbm, sizeof(BITMAP), &bm); ! 451: SelectObject(hdcBits,hbm); ! 452: f = BitBlt(hdc,x,y,bm.bmWidth, bm.bmHeight,hdcBits,0,0,SRCCOPY); ! 453: DeleteDC(hdcBits); ! 454: } ! 455: ! 456: ! 457: ! 458: ! 459: ! 460: ! 461: ! 462: /**************************************************************************\ ! 463: * function: BuildBitmapStrips ! 464: * ! 465: * input parameters: ! 466: * hwnd - window this will all be painted on some day, needed for GetDC ! 467: * lprectClient - Pointer to client window rect, bitmap strips are this high ! 468: * parFonts - array with all the font information. ! 469: * nFaces - number of face names (array size of parFonts). ! 470: * ! 471: * Once the fonts have all been queried, create bitmaps and HDCs for them, and ! 472: * draw the different fonts into the different bitmap strips. ! 473: \**************************************************************************/ ! 474: VOID BuildBitmapStrips (HWND hwnd, LPRECT lprectClient, ! 475: PARFONTS parFonts, int nFaces) ! 476: { ! 477: int i,j; ! 478: HFONT hNewFont; ! 479: HBITMAP hbm; ! 480: HBITMAP hbmtt, hbmdevice; ! 481: RECT rectClip, rectStrip; ! 482: HDC hdc; ! 483: int height; ! 484: int rightshift; ! 485: ! 486: /* load 2 bitmaps used to "tag" true type and printer fonts. */ ! 487: hbmtt = LoadBitmap (hInst, "bmtt"); ! 488: hbmdevice = LoadBitmap (hInst, "bmdevice"); ! 489: ! 490: /* establish bounds of vertical strip that all fonts are drawn into. */ ! 491: hdc = GetDC (hwnd); ! 492: rectStrip.left = rectStrip.top =0; ! 493: rectStrip.right = CXDEF; ! 494: rectStrip.bottom = (lprectClient->bottom - lprectClient->top); ! 495: ! 496: ! 497: /* step through all of the face names. For each one, compute the cySpace- ! 498: * i.e. number of pixels per entry. also create a memory DC that we can ! 499: * draw the font into. This DC provides the STRIP later blt'ed out at ! 500: * paint time. ! 501: */ ! 502: for (i= 0; i<nFaces; i++) { ! 503: parFonts[i].cySpace = rectStrip.bottom / parFonts[i].nFonts; ! 504: parFonts[i].hdc = CreateCompatibleDC (hdc); ! 505: ! 506: /* When there is only one font, then make a small bitmap. If there ! 507: * is more than one, then make a bitmap the whole height of the window. ! 508: */ ! 509: height = (parFonts[i].nFonts == 1) ? ! 510: parFonts[i].lf[0].lfHeight + ALLFONTBORDER : ! 511: rectStrip.bottom; ! 512: hbm = CreateCompatibleBitmap (hdc, rectStrip.right,height); ! 513: ! 514: SelectObject (parFonts[i].hdc, hbm); ! 515: FillRect (parFonts[i].hdc, &rectStrip, GetStockObject(WHITE_BRUSH)); ! 516: SelectObject (parFonts[i].hdc, GetStockObject(NULL_BRUSH)); ! 517: ! 518: /* step through each font for the face name. Establish a bounding ! 519: * rectangle for the name, write the name and mark with bitmaps if apropos ! 520: */ ! 521: for (j = 0; j<parFonts[i].nFonts; j++) { ! 522: rectClip.left = 0; ! 523: rectClip.right = rectClip.left + CXDEF - 5; ! 524: rectClip.top = j*parFonts[i].cySpace+ALLFONTBORDER; ! 525: rectClip.bottom = rectClip.top+ parFonts[i].lf[j].lfHeight; ! 526: rightshift = 0; ! 527: ! 528: ! 529: /* for true type fonts, add special bitmap on left, top */ ! 530: if (!(parFonts[i].Type[j] & RASTER_FONTTYPE)) { ! 531: DrawBitmapXY (parFonts[i].hdc, hbmtt,rectClip.left,rectClip.top); ! 532: rightshift = BMSIZE; ! 533: } ! 534: ! 535: ! 536: /* for printer fonts, add printer bitmap on left, shifted down ! 537: * for display fonts, create a logical font to draw the face name with. ! 538: */ ! 539: if (parFonts[i].Type[j] & DEVICE_FONTTYPE) { ! 540: DrawBitmapXY (parFonts[i].hdc, hbmdevice,rectClip.left,rectClip.top+ BMSIZE); ! 541: rightshift = BMSIZE; ! 542: hNewFont = NULL; ! 543: } else { ! 544: hNewFont = CreateFontIndirect (&(parFonts[i].lf[j])); ! 545: SelectObject (parFonts[i].hdc, hNewFont); ! 546: } ! 547: ! 548: /* iff bitmap drawn, shift text over to the right. */ ! 549: rectClip.left+=rightshift; ! 550: ! 551: /* draw the face name in the rectangle allotted. */ ! 552: ExtTextOut (parFonts[i].hdc, ! 553: rectClip.left, rectClip.top, ETO_CLIPPED, ! 554: &rectClip, ! 555: parFonts[i].lf[j].lfFaceName, ! 556: strlen(parFonts[i].lf[j].lfFaceName), ! 557: NULL ); ! 558: ! 559: ! 560: DeleteObject (hNewFont); ! 561: } ! 562: } ! 563: ! 564: /* make one final strip on the far right side as a white space buffer */ ! 565: hbm = CreateCompatibleBitmap (hdc, rectStrip.right, rectStrip.bottom); ! 566: SelectObject (parFonts[nFaces].hdc, hbm); ! 567: FillRect (parFonts[nFaces].hdc, &rectStrip, GetStockObject(WHITE_BRUSH)); ! 568: ! 569: ReleaseDC (hwnd, hdc); ! 570: DeleteObject (hbmtt); ! 571: DeleteObject (hbmdevice); ! 572: } ! 573: ! 574: ! 575: ! 576: ! 577: ! 578: /* In the callback functions from the enumerations, there is a limited ! 579: * ability to pass in parameters. For that reason, declare the following ! 580: * global variables to be used by any of the call back functions. ! 581: */ ! 582: HDC hdcGlobal; ! 583: PARFONTS parFontsGlobal; ! 584: int iFace,jFont; ! 585: int nFaces; ! 586: ! 587: /* General call structure: ! 588: * ! 589: * BuildFontList() ! 590: * EnumFonts ! 591: * MyEnumCount() ! 592: * LocalAlloc ! 593: * EnumFonts ! 594: * MyEnumFaces() ! 595: * EnumFonts ! 596: * MyEnumCount() ! 597: * LocalAlloc ! 598: * LocalAlloc ! 599: * LocalAlloc ! 600: * EnumFonts ! 601: * MyEnumCopy() ! 602: */ ! 603: ! 604: ! 605: ! 606: /**************************************************************************\ ! 607: * function: BuildFontList ! 608: * ! 609: * input parameters: ! 610: * hdcIn - hdc to query the fonts for. ! 611: * retnFaces - (OUT) pointer to nFaces value ! 612: * ! 613: * Enumerate all of the fonts for this DC allocating and filling up the ! 614: * parFonts structure as needed. ! 615: \**************************************************************************/ ! 616: PARFONTS BuildFontList(HDC hdcIn, LPINT retnFaces) ! 617: { ! 618: ! 619: nFaces = 0; ! 620: ! 621: /* hdcGlobal is global variable also used by the callback functions. */ ! 622: hdcGlobal = hdcIn; ! 623: ! 624: /* count the total number of face names. */ ! 625: EnumFonts (hdcGlobal, NULL, (FONTENUMPROC)MyEnumCount, (LPARAM)&nFaces); ! 626: ! 627: ! 628: /* allocate the pointer to the array of PArFont structures. */ ! 629: parFontsGlobal = (PARFONTS)LocalAlloc (LPTR, sizeof(ARFONTS) * (nFaces+1)); ! 630: ! 631: /* step through all fonts again. For each one fill a LOGFONT and ! 632: * a TEXTMETRIC stucture. ! 633: */ ! 634: iFace = 0; ! 635: EnumFonts (hdcGlobal, NULL, (FONTENUMPROC)MyEnumFaces, (LPARAM)NULL); ! 636: ! 637: *retnFaces = nFaces; ! 638: return parFontsGlobal; ! 639: } ! 640: ! 641: ! 642: ! 643: ! 644: ! 645: ! 646: ! 647: /**************************************************************************\ ! 648: * function: MyEnumFaces ! 649: * ! 650: * input parameters: c.f. EnumFonts ! 651: * ! 652: * Count the number of fonts for this particular face name. Allocate the ! 653: * LOGFONT and TEXTMETRIC arrays large enough to hold all of them. Then ! 654: * enumerate the fonts once again to fill in these arrays. ! 655: \**************************************************************************/ ! 656: int APIENTRY MyEnumFaces( ! 657: LPLOGFONT lpLogFont, ! 658: LPTEXTMETRIC lpTEXTMETRICs, ! 659: DWORD fFontType, ! 660: LPVOID lpData) ! 661: { ! 662: int nFonts; ! 663: ! 664: ! 665: UNREFERENCED_PARAMETER (lpTEXTMETRICs); ! 666: UNREFERENCED_PARAMETER (fFontType); ! 667: UNREFERENCED_PARAMETER (lpData); ! 668: ! 669: ! 670: nFonts = 0; ! 671: EnumFonts (hdcGlobal, lpLogFont->lfFaceName, (FONTENUMPROC)MyEnumCount, (LPARAM)&nFonts); ! 672: ! 673: ! 674: parFontsGlobal[iFace].lf = (LPLOGFONT)LocalAlloc (LPTR, sizeof(LOGFONT) * nFonts); ! 675: parFontsGlobal[iFace].tm = (LPTEXTMETRIC)LocalAlloc (LPTR, sizeof(TEXTMETRIC) * nFonts); ! 676: parFontsGlobal[iFace].Type = (LPINT)LocalAlloc (LPTR, sizeof(int) * nFonts); ! 677: ! 678: if ((parFontsGlobal[iFace].lf == NULL) || ! 679: (parFontsGlobal[iFace].tm == NULL) || ! 680: (parFontsGlobal[iFace].Type == NULL)) { ! 681: MessageBox (hwndMain, "alloc failed", "HEY!", MB_ICONSTOP | MB_OK); ! 682: return FALSE; ! 683: } ! 684: ! 685: parFontsGlobal[iFace].nFonts = nFonts; ! 686: ! 687: jFont = 0; ! 688: EnumFonts (hdcGlobal, lpLogFont->lfFaceName, (FONTENUMPROC)MyEnumCopy, (LPARAM)NULL); ! 689: ! 690: iFace++; ! 691: ! 692: return TRUE; ! 693: } ! 694: ! 695: ! 696: ! 697: /**************************************************************************\ ! 698: * function: MyEnumCopy ! 699: * ! 700: * input parameters: c.f. EnumFonts ! 701: * ! 702: * Each time that this function is called, copy the LOGFONT and TEXTMETRIC ! 703: * structures into the proper place in the global arrays. Incr jFont. ! 704: \**************************************************************************/ ! 705: int APIENTRY MyEnumCopy( ! 706: LPLOGFONT lpLogFont, ! 707: LPTEXTMETRIC lpTEXTMETRICs, ! 708: DWORD fFontType, ! 709: LPVOID lpData) ! 710: { ! 711: LOGFONT *lplf; ! 712: TEXTMETRIC *lptm; ! 713: int *pType; ! 714: ! 715: UNREFERENCED_PARAMETER (lpData); ! 716: ! 717: lplf = parFontsGlobal[iFace].lf; ! 718: lptm = parFontsGlobal[iFace].tm; ! 719: pType = parFontsGlobal[iFace].Type; ! 720: ! 721: lplf[jFont] = *lpLogFont; ! 722: lptm[jFont] = *lpTEXTMETRICs; ! 723: pType[jFont] = fFontType; ! 724: ! 725: jFont++; ! 726: return TRUE; ! 727: } ! 728: ! 729: ! 730: ! 731: /**************************************************************************\ ! 732: * function: MyEnumCount ! 733: * ! 734: * input parameters: c.f. EnumFonts ! 735: * ! 736: * Simply increment the variable that lpData points to. ! 737: \**************************************************************************/ ! 738: int APIENTRY MyEnumCount( ! 739: LPLOGFONT lpLogFont, ! 740: LPTEXTMETRIC lpTEXTMETRICs, ! 741: DWORD fFontType, ! 742: LPINT lpData) ! 743: { ! 744: UNREFERENCED_PARAMETER (lpLogFont); ! 745: UNREFERENCED_PARAMETER (lpTEXTMETRICs); ! 746: UNREFERENCED_PARAMETER (fFontType); ! 747: ! 748: (*lpData)++; ! 749: return TRUE; ! 750: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.