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