![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to font.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / cdtest|
Return to font.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / cdtest |
1.1 root 1: /************************************************************************
2:
3: File: font.c
4:
5: Purpose:
6:
7: Contains all functions pertinent to CDTEST's Font dialog.
8:
9: Functions:
10:
11: DoFontDlg() -- Creates CDTEST's font dialog.
12:
13: FontProc() -- Callback for CDTEST's font dialog.
14:
15: InitFontStruct() -- Fills a CHOOSEFONT structure with some defaults.
16:
17: FillFontDlg() -- Fills CDTEST's font dialog with the contents
18: of a CHOOSEFONT structure.
19:
20: GetFontDlg() -- Retrieves the contents of CDTEST's font dialog
21: and fills a CHOOSEFONT structure with them.
22:
23: GetHdc() -- Creates and returns an HDC
24:
25: LogFontProc() -- Callback function for the logfont dlg.
26:
27: InitLogFontStruct() -- Fills a LOGFONT structure with some defaults.
28:
29: FillLogFontDlg() -- Fills the LOGFONT dlg with the values in
30: a LOGFONT structure.
31:
32: GetLogFontDlg() -- Retrieves the user's edits in the LogFont dlg
33: and puts them in a LOGFONT structure.
34:
35: FontHookProc() -- Callback function for CHOOSEFONT->lpfnHook
36:
37: GetFontDlgHandle() -- Creates a handle to the custom template and
38: returns a handle to it.
39:
40: EnumFontsProc() -- Callback function for EnumFontFamilies()
41:
42: FillFontsBox() -- Fills CDTEST's font list box with requested fonts
43:
44: ResetCheckBoxes() -- handles the font choices check box manipulations
45:
46: HandleFontCheckBox() -- Handles the WM_COMMAND messages from the font
47: choices check boxes.
48:
49: DoChooseFontStuff() -- Calls the ChooseFont() function.
50:
51: FontThreadProc1() -- Starting address for the first thread.
52:
53: FontThreadProc2() -- Starting address for the second thread.
54:
55: MultiThreadFontDlg() -- Creates two threads which each create a
56: ChooseFont() dialog.
57:
58: FontEnableButtons() -- Enables or disables CDTEST's font dialog buttons.
59: Necessary for multithreading part of this app.
60:
61: ************************************************************************/
62:
63:
64: #include <windows.h>
65: #include <commdlg.h>
66: #include <stdlib.h>
67: #include <winnls.h>
68: #include "cdtest.h"
69: #include "font.h"
70: #include "logfont.h"
71:
72:
73:
74: /* some definitions that will help us tell the difference between
75: screen and printer fonts */
76:
77: #define FONT_TYPE_WYSIWYG 1
78: BOOL bScreen ;
79:
80:
81:
82: /* function prototypes and general variables */
83:
84: void InitFontStruct(HWND, LPCHOOSEFONT) ;
85: void FillFontDlg(HWND, LPCHOOSEFONT) ;
86: void GetFontDlg(HWND, LPCHOOSEFONT) ;
87: HDC GetHdc(HWND, int) ;
88: void InitLogFontStruct(HWND, LPLOGFONT) ;
89: void FillLogFontDlg(HWND, LPLOGFONT) ;
90: void GetLogFontDlg(HWND, LPLOGFONT) ;
91: BOOL APIENTRY LogFontProc(HWND, UINT, UINT, LONG) ;
92: UINT APIENTRY FontHookProc(HWND, UINT, UINT, LONG) ;
93: int CALLBACK EnumFontsProc(LPLOGFONT, LPTEXTMETRIC, DWORD, LONG) ;
94: void FillFontsBox(HWND, DWORD) ;
95: void ResetCheckBoxes(HWND) ;
96: void HandleFontCheckBox(HWND, int) ;
97: void DoChooseFontStuff(HWND, LPCHOOSEFONT) ;
98:
99:
100:
101: /* Global variables and some external variables and functions */
102:
103: DWORD dwFontFlag ;
104: PRINTDLG pfd ;
105: BOOL bLogFontParam ;
106: LOGFONT lfWM_CF_LF ; //for the WM_CHOOSEFONT_GETLOGFONT message
107: extern UINT uMode ;
108: extern LONG MyAtol(LPTSTR, BOOL, LPBOOL) ;
109: HANDLE hResFont, hDialogFont ;
110: HANDLE GetFontDlgHandle(void) ;
111: CHOOSEFONT cf ;
112: LOGFONT lf ;
113: HDC hdc ;
114: TCHAR szFaceName[50] ;
115: TCHAR szFontTemplate[50] ;
116: TCHAR szFontStyle[50] ;
117: #define HDCSCREEN 1
118: #define HDCPRINTER 2
119: #define HDCNULL 3
120: #define HDCINVALID 4
121: INT nHdcType ;
122:
123:
124:
125: /* Multithreading stuff */
126:
127: HANDLE hFontThread1 ;
128: HANDLE hFontThread2 ;
129: DWORD dwFontThreadID1 ;
130: DWORD dwFontThreadID2 ;
131: DWORD dwFontThreadParm1 ;
132: DWORD dwFontThreadParm2 ;
133: DWORD FontThreadProc1(LPDWORD) ;
134: DWORD FontThreadProc2(LPDWORD) ;
135: HANDLE hwndMainFont ;
136: int nOpenFontDialogCount ;
137: CHOOSEFONT cfThread1 ;
138: CHOOSEFONT cfThread2 ;
139: void MultiThreadFontDlg(void) ;
140: void EnableFontButtons(HWND, BOOL) ;
141:
142:
143:
144:
145: /************************************************************************
146:
147: Function: DoFontDlg(HWND)
148:
149: Purpose:
150:
151: To create the CDTEST's font dialog
152:
153: Returns: Nothing.
154:
155: Comments:
156:
157:
158: ************************************************************************/
159:
160: void DoFontDialog(HWND hwnd)
161: {
162:
163:
164: DialogBox(hInst, MAKEINTRESOURCE(ID_FONTDIALOG),
165: hwnd, FontProc) ;
166:
167: }
168:
169:
170:
171:
172:
173:
174:
175: /************************************************************************
176:
177: Function: FontProc(HWND, UINT, UINT, LONG)
178:
179: Purpose:
180:
181: Callback function for CDTEST's font dialog.
182:
183: Returns: TRUE or FALSE depending on the situation.
184:
185: Comments:
186:
187:
188: ************************************************************************/
189:
190:
191: BOOL APIENTRY FontProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
192: {
193: BOOL b ;
194: TCHAR szNum[30] ;
195:
196: switch (msg)
197: {
198: case WM_INITDIALOG:
199:
200: InitLogFontStruct(hwnd, &lf) ; //fill (struct lf) so the choosefont
201: InitFontStruct(hwnd, &cf) ; //struct can use it
202: FillFontDlg(hwnd, &cf) ;
203:
204: CheckRadioButton(hwnd, ID_HDCSCREEN, ID_HDCPRINTER, ID_HDCSCREEN) ;
205: nHdcType = HDCSCREEN ;
206:
207: dwFontFlag = cf.Flags ;
208:
209: FillFontsBox(hwnd, dwFontFlag) ;
210:
211: ResetCheckBoxes(hwnd) ;
212:
213: *(&cfThread1) = *(&cfThread2) = *(&cf) ;
214:
215: hwndMainFont = hwnd ;
216: nOpenFontDialogCount = 0 ;
217:
218: SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEF)) ;
219:
220: break ;
221:
222:
223: case UMSG_DECREMENTDLGCOUNT: // user defined message. This is send by
224: // the functions that are executing when
225: // a new thread is created. When these
226: // Thread functions end, they should send
227: // this message.
228:
229: nOpenFontDialogCount-- ;
230:
231: if (nOpenFontDialogCount == 0)
232: EnableFontButtons(hwnd, TRUE) ;
233:
234: break ;
235:
236:
237: case WM_CF_LF:
238:
239: /* If this message comes in, we know that the user clicked the
240: button that tells the ChooseFont() dialog to tell the parent
241: to send the WM_CHOOSEFONT_GETLOGFONT message. So what we will
242: do is send the message and then show the user what was in the
243: logfont by calling creating the Logfont dialog box */
244:
245:
246: SendMessage((HWND) lParam, WM_CHOOSEFONT_GETLOGFONT,
247: 0, (LPARAM) &lfWM_CF_LF) ;
248:
249: bLogFontParam = TRUE ; //tells us if we are doing normal logfont
250: //processing or answering the WM_CF_LF message.
251:
252: DialogBoxParam(hInst, MAKEINTRESOURCE(ID_LOGFONTDIALOG),
253: (HWND) lParam, LogFontProc, (LPARAM) &lf) ;
254:
255: bLogFontParam = FALSE ;
256:
257: break ;
258:
259:
260: case WM_COMMAND:
261: {
262: switch (LOWORD(wParam))
263: {
264: case IDOK:
265: DoChooseFontStuff(hwnd, &cf) ; //create the dialog.
266: break ;
267:
268: case IDCANCEL:
269: EndDialog(hwnd, FALSE) ;
270: break ;
271:
272: case ID_RESETFONT:
273:
274: InitLogFontStruct(hwnd, &lf) ; //reset all the structures.
275: InitFontStruct(hwnd, &cf) ;
276: FillFontDlg(hwnd, &cf) ; //refill the dialog.
277:
278: CheckRadioButton(hwnd, ID_HDCSCREEN, ID_HDCPRINTER, ID_HDCSCREEN) ;
279: nHdcType = HDCSCREEN ;
280:
281: SendDlgItemMessage(hwnd, ID_NULLSTRUCTFONT, BM_SETCHECK, (WPARAM) 0, (LPARAM)0) ;
282: SendDlgItemMessage(hwnd, ID_PRELOADEDFONT, BM_SETCHECK, (WPARAM) 0, (LPARAM)0) ;
283:
284: dwFontFlag = cf.Flags ;
285: FillFontsBox(hwnd, dwFontFlag) ;
286: ResetCheckBoxes(hwnd) ;
287:
288: SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEF)) ;
289:
290: break ;
291:
292:
293: case ID_HDCSCREEN:
294: nHdcType = HDCSCREEN ;
295: break ;
296:
297: case ID_HDCPRINTER:
298: nHdcType = HDCPRINTER ;
299: break ;
300:
301: case ID_HDCNULL:
302: nHdcType = HDCNULL ;
303: break ;
304:
305: case ID_HDCINVALID:
306: nHdcType = HDCINVALID ;
307: break ;
308:
309: case ID_EDITLOGFONT:
310:
311: /* Get the address of the logfont and then show the user what
312: is in it with the Logfont dialog box */
313:
314: GetDlgItemText(hwnd, ID_LOGFONTF, szNum, 30) ;
315: cf.lpLogFont = (LPLOGFONT) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
316:
317: DialogBox(hInst, MAKEINTRESOURCE(ID_LOGFONTDIALOG),
318: hwnd, LogFontProc) ;
319: break ;
320:
321:
322: case F_TTONLY:
323: case F_ANSIONLY:
324: case F_PRINTERFONTS:
325: case F_SCREENFONTS:
326: case F_FIXEDPITCHONLY:
327: case F_NOOEMFONTS:
328: case F_NOVECTORFONTS:
329: case F_SCALABLEONLY:
330: case F_WYSIWYG:
331: HandleFontCheckBox(hwnd, LOWORD(wParam)) ;
332: break ;
333:
334:
335: case ID_MULTITHREADFONT:
336:
337: /* Set the dialog count to 2, disable the buttons in CDTEST's font
338: dialog so the user can't do anything until last dialog has
339: been terminated */
340:
341: nOpenFontDialogCount = 2 ;
342:
343: EnableFontButtons(hwndMainFont, FALSE) ;
344:
345: /* And then do the multithreading */
346:
347: MultiThreadFontDlg() ;
348:
349: break ;
350:
351:
352: default: break ;
353: }
354: }
355:
356: default:
357:
358: /*
359: If the help button is pressed in the ChooseFont()
360: dialog, it will send a message Registered with RegisterWindowMessage()
361: to the parent window. The message nHelpMessage was registered
362: at application startup
363:
364: It must be detected with an IF statement because the value
365: returned by RegisterWindowMessage() is not a constant
366: */
367:
368: if (msg == nHelpMessage)
369: MessageBox(GetForegroundWindow(), TEXT("Hello from the help button"),
370: TEXT("Font Help Button"), MB_OK | MB_APPLMODAL) ;
371: break ;
372: }
373:
374: return FALSE ;
375: }
376:
377:
378:
379:
380:
381:
382:
383:
384: /************************************************************************
385:
386: Function: InitFontStruct(HWND, LPCHOOSEFONT)
387:
388: Purpose:
389:
390: Fill the CHOOSEFONT structure passed as the second parameter with
391: some default values.
392:
393: Returns: Nothing.
394:
395: Comments:
396:
397:
398: ************************************************************************/
399:
400: void InitFontStruct(HWND hwnd, LPCHOOSEFONT pcf)
401: {
402: pcf->lStructSize = sizeof(CHOOSEFONT) ;
403: pcf->hwndOwner = hwnd ;
404: pcf->hDC = (HDC) 0 ;
405: pcf->lpLogFont = &lf ;
406: pcf->iPointSize = 24 ;
407: pcf->Flags = CF_EFFECTS | CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_SHOWHELP | CF_APPLY ;
408: pcf->rgbColors = RGB(0, 255, 0) ;
409: pcf->lCustData = 0L ;
410: pcf->lpfnHook = FontHookProc ;
411:
412: lstrcpy(szFontTemplate, TEXT("fonttemp")) ;
413: pcf->lpTemplateName = szFontTemplate ;
414:
415: pcf->hInstance = (HANDLE) hInst ;
416:
417: lstrcpy(szFontStyle, TEXT("Bold")) ;
418: pcf->lpszStyle = szFontStyle ;
419:
420: pcf->nFontType = SCREEN_FONTTYPE ;
421:
422: pcf->nSizeMin = 8 ;
423: pcf->nSizeMax = 50 ;
424: }
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435: /************************************************************************
436:
437: Function: FillFontDlg(HWND, LPCHOOSEFONT)
438:
439: Purpose:
440:
441: Fill CDTEST's font dialog with the values in the CHOOSEFONT structure
442: passed via the second parameter.
443:
444: Returns: Nothing.
445:
446: Comments:
447:
448:
449: ************************************************************************/
450:
451: void FillFontDlg(HWND hwnd, LPCHOOSEFONT pcf)
452: {
453: wsprintf(szTemp, szLongFilter, pcf->lStructSize) ;
454: SetDlgItemText(hwnd, ID_STRUCTSIZEF, szTemp) ;
455:
456: wsprintf(szTemp, szLongFilter, (DWORD) pcf->hwndOwner) ;
457: SetDlgItemText(hwnd, ID_HWNDOWNERF, szTemp) ;
458:
459: wsprintf(szTemp, szLongFilter, (DWORD) pcf->hDC) ;
460: SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
461:
462: wsprintf(szTemp, szLongFilter, (DWORD) pcf->hDC) ;
463: SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
464:
465: wsprintf(szTemp, szLongFilter, (DWORD) pcf->lpLogFont) ;
466: SetDlgItemText(hwnd, ID_LOGFONTF, szTemp) ;
467:
468: wsprintf(szTemp, szLongFilter, (DWORD) pcf->iPointSize) ;
469: SetDlgItemText(hwnd, ID_POINTSIZEF, szTemp) ;
470:
471: wsprintf(szTemp, szLongFilter, pcf->Flags) ;
472: SetDlgItemText(hwnd, ID_FLAGSF, szTemp) ;
473:
474: wsprintf(szTemp, szLongFilter, pcf->rgbColors) ;
475: SetDlgItemText(hwnd, ID_RGBCOLORSF, szTemp) ;
476:
477: wsprintf(szTemp, szLongFilter, pcf->lCustData) ;
478: SetDlgItemText(hwnd, ID_CUSTDATAF, szTemp) ;
479:
480: wsprintf(szTemp, szLongFilter, (DWORD) pcf->lpfnHook) ;
481: SetDlgItemText(hwnd, ID_HOOKF, szTemp) ;
482:
483: SetDlgItemText(hwnd, ID_TEMPLATEF, pcf->lpTemplateName) ;
484:
485: wsprintf(szTemp, szLongFilter, (DWORD) pcf->hInstance) ;
486: SetDlgItemText(hwnd, ID_HINSTANCEF, szTemp) ;
487:
488: SetDlgItemText(hwnd, ID_STYLEF, pcf->lpszStyle) ;
489:
490: wsprintf(szTemp, szLongFilter, (int) pcf->nFontType) ;
491: SetDlgItemText(hwnd, ID_FONTTYPEF, szTemp) ;
492:
493: wsprintf(szTemp, szLongFilter, (int) pcf->nSizeMin) ;
494: SetDlgItemText(hwnd, ID_SIZEMINF, szTemp) ;
495:
496: wsprintf(szTemp, szLongFilter, (int) pcf->nSizeMax) ;
497: SetDlgItemText(hwnd, ID_SIZEMAXF, szTemp) ;
498:
499: }
500:
501:
502:
503:
504:
505:
506:
507: /************************************************************************
508:
509: Function: GetFontDlg(HWND, LPCHOOSEFONT)
510:
511: Purpose:
512:
513: Retrieve the users edits from CDTEST's font dialog and put them
514: in the CHOOSEFONT structure passed in as the second parameter
515:
516: Returns: Nothing.
517:
518: Comments:
519:
520:
521: ************************************************************************/
522:
523: void GetFontDlg(HWND hwnd, LPCHOOSEFONT pcf)
524: {
525: BOOL b ;
526: TCHAR szNum[30] ;
527:
528: #define WSIZEFO 30
529:
530: GetDlgItemText(hwnd, ID_STRUCTSIZEF, szNum, WSIZEFO) ;
531: pcf->lStructSize = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
532:
533: GetDlgItemText(hwnd, ID_HWNDOWNERF, szNum, WSIZEFO) ;
534: pcf->hwndOwner = (HWND) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
535:
536: GetDlgItemText(hwnd, ID_LOGFONTF, szNum, WSIZEFO) ;
537: pcf->lpLogFont = (LPLOGFONT) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
538:
539: GetDlgItemText(hwnd, ID_POINTSIZEF, szNum, WSIZEFO) ;
540: pcf->iPointSize = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
541:
542: GetDlgItemText(hwnd, ID_FLAGSF, szNum, WSIZEFO) ;
543: pcf->Flags = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
544:
545: GetDlgItemText(hwnd, ID_RGBCOLORSF, szNum, WSIZEFO) ;
546: pcf->rgbColors = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
547:
548: GetDlgItemText(hwnd, ID_CUSTDATAF, szNum, WSIZEFO) ;
549: pcf->lCustData = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
550:
551: GetDlgItemText(hwnd, ID_HOOKF, szNum, WSIZEFO) ;
552: pcf->lpfnHook = (LPCFHOOKPROC) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
553:
554: GetDlgItemText(hwnd, ID_TEMPLATEF, szFontTemplate, 50) ;
555:
556: GetDlgItemText(hwnd, ID_HINSTANCEF, szNum, WSIZEFO) ;
557: pcf->hInstance = (HANDLE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
558:
559: GetDlgItemText(hwnd, ID_STYLEF, szFontStyle, 50) ;
560:
561: GetDlgItemText(hwnd, ID_FONTTYPEF, szNum, WSIZEFO) ;
562: pcf->nFontType = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
563:
564: GetDlgItemText(hwnd, ID_SIZEMINF, szNum, WSIZEFO) ;
565: pcf->nSizeMin = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
566:
567: GetDlgItemText(hwnd, ID_SIZEMAXF, szNum, WSIZEFO) ;
568: pcf->nSizeMax = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
569: }
570:
571:
572:
573:
574:
575:
576:
577: /************************************************************************
578:
579: Function: GetHdc(HWND, int)
580:
581: Purpose:
582:
583: Creates and returns an HDC of the type specified.
584:
585:
586: Returns: The HDC that it creates.
587:
588:
589: Comments:
590:
591: The NULL and INVALID HDCs are only useful to test if the common dialogs
592: handle an HDC that is not useful, but this function is also necessary
593: in that the HDC must be a printer HDC if ChooseFont() is called
594: with the CF_PRINTERFONTS flag bit set.
595:
596: To tell ChooseFont() to list only printer fonts:
597:
598: 1. Set the HDC in CDTEST's font dialog to "Printer"
599:
600: 2. Set the "Flags" edit box CF_PRINTERFONTS
601:
602:
603: ************************************************************************/
604:
605:
606:
607: HDC GetHdc(HWND hwnd, int nType)
608: {
609: switch (nType)
610: {
611: case HDCSCREEN:
612: return GetDC(hwnd) ;
613: break ;
614:
615: case HDCNULL:
616: return (HDC) 0 ;
617: break ;
618:
619: case HDCINVALID:
620: return (HDC) 999 ;
621: break ;
622:
623: case HDCPRINTER:
624:
625: /* To get the HDC of the current printer, fill out a PRINTDLG
626: structure, and set it's flags to (PD_RETURNDC | PD_RETURNDEFAULT).
627: This will tell PrintDlg() to create you an HDC but not show
628: the Print dialog box. */
629:
630: pfd.lStructSize = sizeof(PRINTDLG) ;
631: pfd.hwndOwner = hwnd ;
632: pfd.hDevMode = (HANDLE) 0 ;
633: pfd.hDevNames = (HANDLE) 0 ;
634: pfd.Flags = PD_RETURNDC | PD_RETURNDEFAULT ; //just get default printer
635: pfd.nFromPage = 0 ;
636: pfd.nToPage = 0 ;
637: pfd.nMinPage = 0 ;
638: pfd.nMaxPage = 0 ;
639: pfd.nCopies = 0 ;
640: pfd.hInstance = (HANDLE) hInst ;
641:
642: if (PrintDlg(&pfd) == 0)
643: MessageBox(hwnd, TEXT("Error: Could not create a printer DC!"),
644: (LPTSTR) NULL, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL) ;
645: else
646: return pfd.hDC ;
647:
648: break ;
649:
650: default:
651: break ;
652: }
653: return (HDC) 0 ;
654: }
655:
656:
657:
658:
659:
660:
661:
662:
663:
664: /************************************************************************
665:
666: Function: LogFontProc(HWND, int)
667:
668: Purpose:
669:
670: The callback proc for the LogFont dialog box
671:
672:
673: Returns: BOOL -- depending on the situation.
674:
675:
676: Comments:
677:
678: ************************************************************************/
679:
680:
681: BOOL APIENTRY LogFontProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
682: {
683: switch (msg)
684: {
685: case WM_INITDIALOG:
686: FillLogFontDlg(hwnd, cf.lpLogFont) ; //start off with the one that
687: //is returned from ChooseFont()
688: break ;
689:
690: case WM_COMMAND:
691: switch(LOWORD(wParam))
692: {
693: case IDOK:
694:
695: GetLogFontDlg(hwnd, &lf) ;
696:
697: cf.lpLogFont = &lf ;
698:
699: EndDialog(hwnd, TRUE) ;
700:
701: break ;
702:
703:
704:
705: case ID_RESETLF:
706:
707: SetFocus(GetDlgItem(hwnd, ID_LFHEIGHT)) ;
708:
709: InitLogFontStruct(hwnd, &lf) ;
710:
711: FillLogFontDlg(hwnd, &lf) ;
712:
713: break ;
714:
715:
716: case IDCANCEL:
717:
718: EndDialog(hwnd, FALSE) ;
719:
720: break ;
721:
722:
723: default:
724: break ;
725: }
726:
727: default: break ;
728: }
729:
730:
731: return FALSE ;
732: }
733:
734:
735:
736:
737:
738:
739:
740: /************************************************************************
741:
742: Function: InitLogFontStruct(HWND, LPLOGFONT)
743:
744: Purpose:
745:
746: Fills the LOGFONT structure passed in as the second parameter with
747: some default values.
748:
749: Returns: Nothing.
750:
751: Comments:
752:
753: ************************************************************************/
754:
755: void InitLogFontStruct(HWND hwnd, LPLOGFONT plf)
756: {
757: plf->lfHeight = 24 ;
758: plf->lfWidth = 20 ;
759: plf->lfEscapement = 0 ;
760: plf->lfOrientation = 10 ;
761: plf->lfWeight = 400 ;
762: plf->lfItalic = FALSE ;
763: plf->lfUnderline = FALSE ;
764: plf->lfStrikeOut = FALSE ;
765: plf->lfCharSet = ANSI_CHARSET ;
766: plf->lfOutPrecision = OUT_DEFAULT_PRECIS ;
767: plf->lfClipPrecision = CLIP_DEFAULT_PRECIS ;
768: plf->lfQuality = DEFAULT_QUALITY ;
769: plf->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE ;
770:
771: szFaceName[0] = (TCHAR) 0 ;
772: lstrcpy(plf->lfFaceName, szFaceName) ;
773: }
774:
775:
776:
777:
778:
779:
780: /************************************************************************
781:
782: Function: FillLogFontDlg(HWND, LPLOGFONT)
783:
784: Purpose:
785:
786: Fills CDTEST's logfont dialog with the values in the logfont that
787: is passed in as the second parameter.
788:
789: Returns: Nothing.
790:
791: Comments:
792:
793: ************************************************************************/
794:
795: void FillLogFontDlg(HWND hwnd, LPLOGFONT plf)
796: {
797: TCHAR szTemp[50] ;
798:
799: LPLOGFONT pl = plf ;
800:
801: if (bLogFontParam) //Are creating this dialog in response to the
802: pl = &lfWM_CF_LF ; //WM_CHOOSEFONT_GETLOGFONT message ?
803:
804: if (!pl) //Avert a ghastly exception error
805: return ;
806:
807: wsprintf(szTemp, szLongFilter, pl->lfHeight) ;
808: SetDlgItemText(hwnd, ID_LFHEIGHT, szTemp) ;
809:
810: wsprintf(szTemp, szLongFilter, pl->lfWidth) ;
811: SetDlgItemText(hwnd, ID_LFWIDTH, szTemp) ;
812:
813: wsprintf(szTemp, szLongFilter, pl->lfEscapement) ;
814: SetDlgItemText(hwnd, ID_LFESCAPEMENT, szTemp) ;
815:
816: wsprintf(szTemp, szLongFilter, pl->lfOrientation) ;
817: SetDlgItemText(hwnd, ID_LFORIENTATION, szTemp) ;
818:
819: wsprintf(szTemp, szLongFilter, pl->lfWeight) ;
820: SetDlgItemText(hwnd, ID_LFWEIGHT, szTemp) ;
821:
822: wsprintf(szTemp, szShortFilter, pl->lfItalic) ;
823: SetDlgItemText(hwnd, ID_LFITALIC, szTemp) ;
824:
825: wsprintf(szTemp, szShortFilter, pl->lfUnderline) ;
826: SetDlgItemText(hwnd, ID_LFUNDERLINE, szTemp) ;
827:
828: wsprintf(szTemp, szShortFilter, pl->lfStrikeOut) ;
829: SetDlgItemText(hwnd, ID_LFSTRIKEOUT, szTemp) ;
830:
831: wsprintf(szTemp, szShortFilter, pl->lfCharSet) ;
832: SetDlgItemText(hwnd, ID_LFCHARSET, szTemp) ;
833:
834: wsprintf(szTemp, szShortFilter, pl->lfOutPrecision) ;
835: SetDlgItemText(hwnd, ID_LFOUTP, szTemp) ;
836:
837: wsprintf(szTemp, szShortFilter, pl->lfClipPrecision) ;
838: SetDlgItemText(hwnd, ID_LFCLIPP, szTemp) ;
839:
840: wsprintf(szTemp, szShortFilter, pl->lfQuality) ;
841: SetDlgItemText(hwnd, ID_LFQUALITY, szTemp) ;
842:
843: wsprintf(szTemp, szShortFilter, pl->lfPitchAndFamily) ;
844: SetDlgItemText(hwnd, ID_LFPITCHANDFAM, szTemp) ;
845:
846: SetDlgItemText(hwnd, ID_LFFACENAME, (LPTSTR) pl->lfFaceName) ;
847: }
848:
849:
850:
851:
852:
853:
854: /************************************************************************
855:
856: Function: GetLogFontDlg(HWND, LPLOGFONT)
857:
858: Purpose:
859:
860: Retrieves the users edits in CDTEST's Logfont dialog and puts them
861: into the LOGFONT struct that is passed as the second parameter.
862:
863: Returns: Nothing.
864:
865: Comments:
866:
867: ************************************************************************/
868:
869: void GetLogFontDlg(HWND hwnd, LPLOGFONT plf)
870: {
871: BOOL b ;
872: TCHAR szNum[30] ;
873:
874: if (bLogFontParam) //if we are just viewing the logfont because we sent a
875: return ; //WM_CHOOSEFONT_GETLOGFONT message, don't change the Logfont Struct
876: //that ChooseFont() gives us...
877:
878: #define LFSIZE 30
879:
880: GetDlgItemText(hwnd, ID_LFHEIGHT, szNum, LFSIZE) ;
881: plf->lfHeight = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
882:
883: GetDlgItemText(hwnd, ID_LFWIDTH, szNum, LFSIZE) ;
884: plf->lfWidth = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
885:
886: GetDlgItemText(hwnd, ID_LFESCAPEMENT, szNum, LFSIZE) ;
887: plf->lfEscapement = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
888:
889: GetDlgItemText(hwnd, ID_LFORIENTATION, szNum, LFSIZE) ;
890: plf->lfOrientation = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
891:
892: GetDlgItemText(hwnd, ID_LFWEIGHT, szNum, LFSIZE) ;
893: plf->lfWeight = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
894:
895: GetDlgItemText(hwnd, ID_LFITALIC, szNum, LFSIZE) ;
896: plf->lfItalic = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
897:
898: GetDlgItemText(hwnd, ID_LFUNDERLINE, szNum, LFSIZE) ;
899: plf->lfUnderline = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
900:
901: GetDlgItemText(hwnd, ID_LFSTRIKEOUT, szNum, LFSIZE) ;
902: plf->lfStrikeOut = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
903:
904: GetDlgItemText(hwnd, ID_LFCHARSET, szNum, LFSIZE) ;
905: plf->lfCharSet = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
906:
907: GetDlgItemText(hwnd, ID_LFOUTP, szNum, LFSIZE) ;
908: plf->lfOutPrecision = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
909:
910: GetDlgItemText(hwnd, ID_LFCLIPP, szNum, LFSIZE) ;
911: plf->lfClipPrecision = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
912:
913: GetDlgItemText(hwnd, ID_LFQUALITY, szNum, LFSIZE) ;
914: plf->lfQuality = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
915:
916: GetDlgItemText(hwnd, ID_LFPITCHANDFAM, szNum, LFSIZE) ;
917: plf->lfPitchAndFamily = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
918:
919: GetDlgItemText(hwnd, ID_LFFACENAME, (LPTSTR) plf->lfFaceName, 32) ;
920: }
921:
922:
923:
924:
925:
926:
927:
928:
929: /************************************************************************
930:
931: Function: FontHookProc(HWND, UINT, UINT, LONG)
932:
933: Purpose: The callback function that acts as the hook proc for
934: the ChooseFont() dialog.
935:
936:
937: Returns: TRUE to discard the message. FALSE to send the message on
938: to the normal dialog processing done by the ChooseFont()
939: function.
940:
941: Comments:
942:
943: ************************************************************************/
944:
945: UINT APIENTRY FontHookProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
946: {
947: LPCHOOSEFONT pCf ;
948: TCHAR szMsg[50] ;
949:
950: switch(msg)
951: {
952: case WM_INITDIALOG:
953:
954: pCf = (LPCHOOSEFONT) lParam ;
955:
956: if (pCf->lCustData != 0L)
957: {
958: wsprintf(szMsg, TEXT("CHOOSEFONT->lCustData is: %ld"), pCf->lCustData) ;
959: MessageBox(hwnd, szMsg, TEXT("lCustData Sent!"), MB_OK) ;
960: }
961:
962: SetWindowText(hwnd, TEXT("Font Hook Proc Dialog")) ;
963:
964: break ;
965:
966: case WM_COMMAND:
967:
968: /* NOTE: This button will only be available if the user creates the
969: ChooseFont() dialog with the CF_ENABLETEMPLATE or CF_ENABLETEMPLATEHANDLE
970: flag.
971:
972: This button will only work if the ChooseFont() dialog is created
973: with the CF_ENABLEHOOK flag. So, to get full functionality from
974: this button:
975:
976: 1. Enter (CF_ENABLEHOOK | CF_ENABLETEMPLATE | CF_SCREENFONTS)
977: in the "Flags" edit box of CDTEST'S Font dialog.
978:
979: 2. Click OK
980: */
981:
982:
983:
984: /* The parent will send the WM_CHOOSEFONT_GETLOGFONT message and
985: display it's findings in a LogFont dialog if it gets this message */
986:
987: if (LOWORD(wParam) == ID_SEND_WM_CF_LF_MSG)
988: SendMessage(GetParent(hwnd), WM_CF_LF, 0, (LPARAM) hwnd) ;
989:
990: break ;
991:
992:
993: default:
994: break ;
995: }
996:
997: return FALSE ; //send msg to the common dialog code
998: }
999:
1000:
1001:
1002:
1003:
1004:
1005:
1006:
1007:
1008: /************************************************************************
1009:
1010: Function: GetFontDlgHandle(void)
1011:
1012: Purpose: Finds and loads the custom template resource and returns a
1013: handle to it.
1014:
1015:
1016: Returns: A handle to the custom template resource.
1017:
1018: Comments:
1019:
1020: ************************************************************************/
1021:
1022: HANDLE GetFontDlgHandle(void)
1023: {
1024:
1025: hResFont = FindResource(hInst, TEXT("fonttemp"), RT_DIALOG) ;
1026:
1027: hDialogFont = LoadResource(hInst, hResFont) ;
1028:
1029:
1030: return hDialogFont ;
1031: }
1032:
1033:
1034:
1035:
1036:
1037:
1038:
1039:
1040: /************************************************************************
1041:
1042: Function: EnumFontsProc(LPLOGFONT, LPTEXTMETRIC, DWORD, LONG)
1043:
1044: Purpose: Acts as a callback function for the EnumFontFamilies()
1045: function.
1046:
1047: Returns: 0 if the font enumeration should stop. 1 to ask for the
1048: next font.
1049:
1050: Comments:
1051:
1052: EnumFontFamilies will find the fonts on the system and call this
1053: function each time it finds a font. Pointers to the LOGFONT and
1054: TEXTMETRIC structures the describe the font are passed as the first
1055: and second arguments, so we can determine if the fonts we get
1056: meet the specs we want. If they do, we can add them to the font
1057: list box in CDTEST's Font dialog.
1058:
1059: NOTE:
1060:
1061: None of this affects the performance of ChooseFont(). This serves
1062: only to illustrate how ChooseFont() finds the fonts you request based
1063: on the flags you pass to the ChooseFont() function.
1064:
1065: The fonts found with this function should be the same as the ones
1066: found by ChooseFont() for any flag combination.
1067:
1068:
1069: ************************************************************************/
1070:
1071:
1072: int CALLBACK EnumFontsProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
1073: DWORD dwStyle, LONG lParam)
1074: {
1075: UINT i ;
1076:
1077: /* check to see if the font is already there right off the bat
1078: and just continue the enumeration if it is... */
1079:
1080:
1081: i = SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_FINDSTRINGEXACT, (WPARAM) 0,
1082: (LONG) (LPTSTR) lplf->lfFaceName) ;
1083:
1084: if (i != LB_ERR)
1085: {
1086: if (bScreen) //if we are adding it for the first time
1087: return 1 ;
1088:
1089: //else, we are adding printer fonts, so if we find one that is already there
1090: //it must be available for both the printer and the screen...
1091:
1092: else
1093: {
1094: SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_SETITEMDATA, i,
1095: FONT_TYPE_WYSIWYG) ;
1096: return 1 ;
1097: }
1098: }
1099:
1100:
1101: //Get rid of any fonts that we don't want...
1102:
1103: if ((dwFontFlag & CF_TTONLY) && (!(dwStyle & TRUETYPE_FONTTYPE)))
1104: return 1 ;
1105:
1106: if ((dwFontFlag & CF_SCALABLEONLY) && (dwStyle & RASTER_FONTTYPE))
1107: return 1 ;
1108:
1109: if ((dwFontFlag & CF_ANSIONLY) && (lplf->lfCharSet != ANSI_CHARSET))
1110: return 1 ;
1111:
1112: if ((dwFontFlag & CF_FIXEDPITCHONLY) && (lplf->lfPitchAndFamily & VARIABLE_PITCH))
1113: return 1 ;
1114:
1115: if ((dwFontFlag & CF_NOVECTORFONTS) && (lplf->lfCharSet == OEM_CHARSET))
1116: return 1 ;
1117:
1118:
1119: //if there is a font to be added, add it.
1120:
1121: if (*(lplf->lfFaceName))
1122: SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_ADDSTRING,
1123: (WPARAM) 0, (LONG) (LPTSTR) lplf->lfFaceName) ;
1124:
1125: return 1 ;
1126: }
1127:
1128:
1129:
1130:
1131:
1132:
1133:
1134:
1135: /************************************************************************
1136:
1137: Function: FillFontsBox(HWND, DWORD)
1138:
1139: Purpose: Enumerates all fonts on the system and sends the ones that
1140: meet the criteria of the dwFlags parameter (CF_SCREENFONTS,
1141: CF_SCALABLEONLY, etc).
1142:
1143: Returns: Nothing.
1144:
1145: Comments:
1146:
1147:
1148: ************************************************************************/
1149:
1150: void FillFontsBox(HWND hwnd, DWORD dwFlags)
1151: {
1152: HDC hdc ;
1153: HWND hwndControl ;
1154: DWORD dwData ;
1155: int nItemCount ;
1156:
1157:
1158: /* Empty the list box, and turn of the redraw because we may need
1159: to remove some fonts after they are added if the user calls this
1160: function with the CF_WYSIWYG flag bit set. */
1161:
1162: SendDlgItemMessage(hwnd, ID_FONTLIST, LB_RESETCONTENT, (WPARAM)0, (LPARAM) 0) ;
1163:
1164: hwndControl = GetDlgItem(hwnd, ID_FONTLIST) ;
1165:
1166: SendMessage(hwndControl, WM_SETREDRAW, FALSE, 0L) ;
1167:
1168:
1169: /* Now call EnumFontFamilies() for each type of HDC requested */
1170:
1171: if (dwFlags & CF_SCREENFONTS)
1172: {
1173: bScreen = TRUE ;
1174: hdc = GetHdc(hwnd, HDCSCREEN) ;
1175: EnumFontFamilies(hdc, (LPTSTR) NULL, (FONTENUMPROC) EnumFontsProc, (LONG) hwnd) ;
1176: ReleaseDC(hwnd, hdc) ;
1177: }
1178:
1179: if (dwFlags & CF_PRINTERFONTS)
1180: {
1181: bScreen = FALSE ;
1182: hdc = GetHdc(hwnd, HDCPRINTER) ;
1183: EnumFontFamilies(hdc, (LPTSTR) NULL, (FONTENUMPROC) EnumFontsProc, (LONG) hwnd) ;
1184: ReleaseDC(hwnd, hdc) ;
1185: }
1186:
1187:
1188: /* Special case: If the CF_WYSIWYG flag is used, we have to enumerate
1189: the fonts in both HDCs and then remove all the ones that are not
1190: both printer fonts and screen fonts. */
1191:
1192: if (dwFontFlag & CF_WYSIWYG)
1193: {
1194: nItemCount = SendDlgItemMessage(hwnd, ID_FONTLIST, LB_GETCOUNT, 0, 0L) ;
1195:
1196: nItemCount-- ; //the list is zero based
1197:
1198: while (nItemCount >= 0)
1199: {
1200: dwData = SendDlgItemMessage(hwnd, ID_FONTLIST, LB_GETITEMDATA, nItemCount, 0L) ;
1201:
1202: if (dwData != FONT_TYPE_WYSIWYG)
1203: {
1204: SendDlgItemMessage(hwnd, ID_FONTLIST, LB_DELETESTRING, nItemCount, 0L) ;
1205: }
1206:
1207: nItemCount-- ;
1208: }
1209: }
1210:
1211:
1212: /* Now redraw the font list */
1213:
1214: SendMessage(hwndControl, WM_SETREDRAW, TRUE, 0L) ;
1215: InvalidateRect(hwndControl, NULL, FALSE) ;
1216:
1217: return ;
1218: }
1219:
1220:
1221:
1222:
1223:
1224:
1225: /************************************************************************
1226:
1227: Function: ResetCheckBoxes(HWND)
1228:
1229: Purpose: Checks the checkboxes that control what fonts are listed in
1230: CDTEST's font list box.
1231:
1232: Returns: Nothing.
1233:
1234: Comments:
1235:
1236:
1237: ************************************************************************/
1238:
1239: void ResetCheckBoxes(HWND hwnd)
1240: {
1241:
1242: SendDlgItemMessage(hwnd, F_TTONLY, BM_SETCHECK, dwFontFlag & CF_TTONLY ? 1 : 0, (LPARAM)0) ;
1243: SendDlgItemMessage(hwnd, F_ANSIONLY, BM_SETCHECK, dwFontFlag & CF_ANSIONLY ? 1 : 0, (LPARAM)0) ;
1244: SendDlgItemMessage(hwnd, F_SCREENFONTS, BM_SETCHECK, dwFontFlag & CF_SCREENFONTS ? 1 : 0, (LPARAM)0) ;
1245: SendDlgItemMessage(hwnd, F_PRINTERFONTS, BM_SETCHECK, dwFontFlag & CF_PRINTERFONTS ? 1 : 0, (LPARAM)0) ;
1246: SendDlgItemMessage(hwnd, F_NOOEMFONTS, BM_SETCHECK, dwFontFlag & CF_NOOEMFONTS ? 1 : 0, (LPARAM)0) ;
1247: SendDlgItemMessage(hwnd, F_NOVECTORFONTS, BM_SETCHECK, dwFontFlag & CF_NOVECTORFONTS ? 1 : 0, (LPARAM)0) ;
1248: SendDlgItemMessage(hwnd, F_SCALABLEONLY, BM_SETCHECK, dwFontFlag & CF_SCALABLEONLY ? 1 : 0, (LPARAM)0) ;
1249: SendDlgItemMessage(hwnd, F_WYSIWYG, BM_SETCHECK, dwFontFlag & CF_WYSIWYG ? 1 : 0, (LPARAM)0) ;
1250: SendDlgItemMessage(hwnd, F_FIXEDPITCHONLY, BM_SETCHECK, dwFontFlag & CF_FIXEDPITCHONLY ? 1 : 0, (LPARAM)0) ;
1251:
1252: }
1253:
1254:
1255:
1256:
1257:
1258:
1259: /************************************************************************
1260:
1261: Function: HandleFontCheckBox(HWND)
1262:
1263: Purpose: If the user clicks one of the fonts in the CDTEST's list of
1264: valid font types, this function will check the correct boxes
1265: and set the correct values in the flag which keeps track of
1266: which fonts are to be enumerated and added to CDTEST's font
1267: list box.
1268:
1269:
1270: Returns: Nothing.
1271:
1272: Comments:
1273:
1274: CF_NOOEMFONTS and CF_NOVECTORFONTS are identical.
1275:
1276:
1277: ************************************************************************/
1278:
1279: void HandleFontCheckBox(HWND hwnd, int nID)
1280: {
1281: DWORD dwTemp ;
1282:
1283: dwTemp = dwFontFlag ;
1284:
1285: switch (nID)
1286: {
1287: case F_TTONLY:
1288:
1289: /* TTONLY is a special case. If we only want Truetype fonts,
1290: turn off irrelevant flags */
1291:
1292: if (!(dwFontFlag & CF_TTONLY)) //if we're turning this flag on...
1293: {
1294: dwFontFlag = 0L ; //turn everyone off but the following:
1295:
1296: dwFontFlag |= CF_TTONLY ;
1297:
1298: if (dwTemp & CF_ANSIONLY)
1299: dwFontFlag |= CF_ANSIONLY ;
1300:
1301: if (dwTemp & CF_FIXEDPITCHONLY)
1302: dwFontFlag |= CF_FIXEDPITCHONLY ;
1303:
1304: if (dwTemp & CF_SCREENFONTS)
1305: dwFontFlag |= CF_SCREENFONTS ;
1306:
1307: if (dwTemp & CF_PRINTERFONTS)
1308: dwFontFlag |= CF_PRINTERFONTS ;
1309: }
1310: else
1311: {
1312: dwFontFlag ^= CF_TTONLY ;
1313: }
1314:
1315:
1316: break ;
1317:
1318: case F_ANSIONLY:
1319: dwFontFlag ^= CF_ANSIONLY ; //otherwise toggle the bit.
1320: dwFontFlag &= ~CF_WYSIWYG ;
1321:
1322: break ;
1323:
1324: case F_PRINTERFONTS:
1325: dwFontFlag ^= CF_PRINTERFONTS ;
1326:
1327: break ;
1328:
1329: case F_SCREENFONTS:
1330: dwFontFlag ^= CF_SCREENFONTS ;
1331:
1332: break ;
1333:
1334: case F_FIXEDPITCHONLY:
1335: dwFontFlag ^= CF_FIXEDPITCHONLY ;
1336:
1337: break ;
1338:
1339: case F_NOOEMFONTS:
1340: dwFontFlag ^= CF_NOOEMFONTS ;
1341:
1342: break ;
1343:
1344: case F_NOVECTORFONTS:
1345: dwFontFlag ^= CF_NOVECTORFONTS ;
1346:
1347: break ;
1348:
1349: case F_SCALABLEONLY:
1350: dwFontFlag ^= CF_SCALABLEONLY ;
1351:
1352: break ;
1353:
1354: case F_WYSIWYG: //We want fonts for both the
1355: //screen and the printer...
1356: dwFontFlag ^= CF_WYSIWYG ;
1357:
1358: if (dwFontFlag & CF_WYSIWYG)
1359: dwFontFlag |= (CF_SCREENFONTS | CF_PRINTERFONTS | CF_SCALABLEONLY) ;
1360:
1361: break ;
1362:
1363: default: break ;
1364: }
1365:
1366: ResetCheckBoxes(hwnd) ;
1367: FillFontsBox(hwnd, dwFontFlag) ;
1368: }
1369:
1370:
1371:
1372:
1373:
1374:
1375:
1376: /************************************************************************
1377:
1378: Function: DoChooseFontStuff(HWND, LPCHOOSEFONT)
1379:
1380: Purpose:
1381:
1382: Calls the ChooseFont() function.
1383:
1384: Returns: Nothing.
1385:
1386: Comments:
1387:
1388:
1389: ************************************************************************/
1390:
1391:
1392: void DoChooseFontStuff(HWND hwnd, LPCHOOSEFONT pcf)
1393: {
1394: BOOL bRet = FALSE ;
1395:
1396: if (IsDlgButtonChecked(hwnd, ID_PRELOADEDFONT) == 1)
1397: {
1398: pcf->hInstance = GetFontDlgHandle() ;
1399: wsprintf(szTemp, szLongFilter, pcf->hInstance) ;
1400: SetDlgItemText(hwnd, ID_HINSTANCEF, szTemp) ;
1401: }
1402:
1403: pcf->hDC = GetHdc(hwnd, nHdcType) ;
1404:
1405: wsprintf(szTemp, szLongFilter, pcf->hDC) ;
1406: SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
1407:
1408:
1409: GetFontDlg(hwnd, pcf) ;
1410:
1411:
1412: if (IsDlgButtonChecked(hwnd, ID_NULLSTRUCTFONT) == 1)
1413: bRet = ChooseFont((LPCHOOSEFONT)NULL) ;
1414: else
1415: bRet = ChooseFont(pcf) ;
1416:
1417: wsprintf(szTemp, szLongFilter, CommDlgExtendedError()) ;
1418: SetDlgItemText(hwnd, ID_ERRORF, szTemp) ;
1419:
1420: if (pcf->hDC)
1421: {
1422: ReleaseDC(hwnd, pcf->hDC) ; //free the HDC that we used if we called
1423: pcf->hDC = (HDC) 0 ; //the function with a valid HDC.
1424: }
1425:
1426: if (hDialogFont)
1427: {
1428: FreeResource(hDialogFont) ;
1429: hDialogFont = (HANDLE) 0 ;
1430: hResFont = (HANDLE) 0 ;
1431: }
1432:
1433: wsprintf(szTemp, szShortFilter, bRet) ; //fill results into the Font dlg
1434: SetDlgItemText(hwnd, ID_RETURNF, szTemp) ;
1435:
1436: FillFontDlg(hwnd, pcf) ;
1437: }
1438:
1439:
1440:
1441:
1442:
1443:
1444: /************************************************************************
1445:
1446: Function: FontThreadProc1(LPDWORD)
1447:
1448: Purpose:
1449:
1450: Acts as the starting address for thread 1
1451:
1452: Returns: Any DWORD value.
1453:
1454: Comments:
1455:
1456:
1457: ************************************************************************/
1458:
1459: DWORD FontThreadProc1(LPDWORD pdw)
1460: {
1461: DoChooseFontStuff(hwndMainFont, &cfThread1) ;
1462:
1463: PostMessage(hwndMainFont, UMSG_DECREMENTDLGCOUNT, 0, 0L ) ;
1464:
1465: return 0L ;
1466: }
1467:
1468:
1469:
1470:
1471:
1472:
1473:
1474: /************************************************************************
1475:
1476: Function: FontThreadProc2(LPDWORD)
1477:
1478: Purpose:
1479:
1480: Acts as the starting address for thread 2
1481:
1482: Returns: Any DWORD value.
1483:
1484: Comments:
1485:
1486:
1487: ************************************************************************/
1488:
1489:
1490: DWORD FontThreadProc2(LPDWORD pdw)
1491: {
1492: DoChooseFontStuff(hwndMainFont, &cfThread2) ;
1493:
1494: PostMessage(hwndMainFont, UMSG_DECREMENTDLGCOUNT, 0, 0L ) ;
1495:
1496: return 0L ;
1497: }
1498:
1499:
1500:
1501:
1502:
1503:
1504:
1505: /************************************************************************
1506:
1507: Function: MultiThreadFontDlg(void)
1508:
1509: Purpose:
1510:
1511: Create the two threads that will in turn create two ChooseFont()
1512: dialogs.
1513:
1514: Returns: Nothing.
1515:
1516: Comments:
1517:
1518: Multithreading note:
1519:
1520: This function will return before the common dialog functions return.
1521: Therefore, do not pass any parameters to this function that will be
1522: referenced by the common dialogs because as soon as this function
1523: ends those parameters will be gone.
1524:
1525: ************************************************************************/
1526:
1527: void MultiThreadFontDlg(void)
1528: {
1529:
1530: dwFontThreadParm1 = dwFontThreadParm2 = 0L ;
1531:
1532: if (!(hFontThread1 = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0,
1533: (LPTHREAD_START_ROUTINE) FontThreadProc1,
1534: &dwFontThreadParm1, CREATE_SUSPENDED, &dwFontThreadID1)))
1535:
1536: {
1537: MessageBox(GetForegroundWindow(), TEXT("Error creating thread 1"), NULL,
1538: MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL) ;
1539:
1540: nOpenFontDialogCount = 0 ;
1541:
1542: EnableFontButtons(hwndMainFont, TRUE) ;
1543:
1544: return ;
1545: }
1546:
1547:
1548: if (!(hFontThread2 = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0,
1549: (LPTHREAD_START_ROUTINE) FontThreadProc2,
1550: &dwFontThreadParm2, CREATE_SUSPENDED, &dwFontThreadID2)))
1551: {
1552: MessageBox(GetForegroundWindow(), TEXT("Error creating thread 2"), NULL,
1553: MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL) ;
1554:
1555: nOpenFontDialogCount = 0 ;
1556:
1557: EnableFontButtons(hwndMainFont, TRUE) ;
1558:
1559: return ;
1560: }
1561:
1562: ResumeThread(hFontThread1) ;
1563: ResumeThread(hFontThread2) ;
1564:
1565: return ;
1566: }
1567:
1568:
1569:
1570:
1571:
1572:
1573: /************************************************************************
1574:
1575: Function: EnableFontButtons(HWND, BOOL)
1576:
1577: Purpose:
1578:
1579: Enables or disables CDTEST's font dialogs buttons based on the
1580: status of the second parameter.
1581:
1582:
1583: Returns: Nothing.
1584:
1585: Comments:
1586:
1587: This is necessary when multithreading in the case of this application.
1588:
1589: ************************************************************************/
1590:
1591: void EnableFontButtons(HWND hwnd, BOOL bEnable)
1592: {
1593: EnableWindow(GetDlgItem(hwnd, IDOK), bEnable) ;
1594: EnableWindow(GetDlgItem(hwnd, IDCANCEL), bEnable) ;
1595: EnableWindow(GetDlgItem(hwnd, ID_RESETFONT), bEnable) ;
1596: EnableWindow(GetDlgItem(hwnd, ID_MULTITHREADFONT), bEnable) ;
1597: EnableWindow(GetDlgItem(hwnd, ID_EDITLOGFONT), bEnable) ;
1598: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.