开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
FONT.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：40k
源码类别：

Windows编程

开发平台：

Visual C++

FONT.C：源码内容
  1. /************************************************************************
  3.   File: font.c
  5.   Purpose:
  7.     Contains all functions pertinent to CDTEST's Font dialog.
  9.   Functions:
  11.      DoFontDlg()          -- Creates CDTEST's font dialog.
  13.      FontProc()           -- Callback for CDTEST's font dialog.
  15.      InitFontStruct()     -- Fills a CHOOSEFONT structure with some defaults.
  17.      FillFontDlg()        -- Fills CDTEST's font dialog with the contents
  18.                              of a CHOOSEFONT structure.
  20.      GetFontDlg()         -- Retrieves the contents of CDTEST's font dialog
  21.                              and fills a CHOOSEFONT structure with them.
  23.      GetHdc()             -- Creates and returns an HDC
  25.      LogFontProc()        -- Callback function for the logfont dlg.
  27.      InitLogFontStruct()  -- Fills a LOGFONT structure with some defaults.
  29.      FillLogFontDlg()     -- Fills the LOGFONT dlg with the values in
  30.                              a LOGFONT structure.
  32.      GetLogFontDlg()      -- Retrieves the user's edits in the LogFont dlg
  33.                              and puts them in a LOGFONT structure.
  35.      FontHookProc()       -- Callback function for CHOOSEFONT->lpfnHook
  37.      GetFontDlgHandle()   -- Creates a handle to the custom template and
  38.                              returns a handle to it.
  40.      EnumFontsProc()      -- Callback function for EnumFontFamilies()
  42.      FillFontsBox()       -- Fills CDTEST's font list box with requested fonts
  44.      ResetCheckBoxes()    -- handles the font choices check box manipulations
  46.      HandleFontCheckBox() -- Handles the WM_COMMAND messages from the font
  47.                              choices check boxes.
  49.      DoChooseFontStuff()  -- Calls the ChooseFont() function.
  51.      FontThreadProc1()    -- Starting address for the first thread.
  53.      FontThreadProc2()    -- Starting address for the second thread.
  55.      MultiThreadFontDlg() -- Creates two threads which each create a
  56.                              ChooseFont() dialog.
  58.      FontEnableButtons()  -- Enables or disables CDTEST's font dialog buttons.
  59.                              Necessary for multithreading part of this app.
  61. ************************************************************************/
  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"
  74. /* some definitions that will help us tell the difference between
  75.    screen and printer fonts */
  77. #define FONT_TYPE_WYSIWYG 1
  78. BOOL bScreen ;
  82. /* function prototypes and general variables */
  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) ;
  101. /* Global variables and some external variables and functions */
  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 ;
  125. /* Multithreading stuff */
  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) ;
  145. /************************************************************************
  147.   Function: DoFontDlg(HWND)
  149.   Purpose:
  151.     To create the CDTEST's font dialog
  153.   Returns: Nothing.
  155.   Comments:
  158. ************************************************************************/
  160. void DoFontDialog(HWND hwnd)
  161. {
  164.   DialogBox(hInst, MAKEINTRESOURCE(ID_FONTDIALOG),
  165.             hwnd, FontProc) ;
  167. }
  175. /************************************************************************
  177.   Function: FontProc(HWND, UINT, UINT, LONG)
  179.   Purpose:
  181.     Callback function for CDTEST's font dialog.
  183.   Returns: TRUE or FALSE depending on the situation.
  185.   Comments:
  188. ************************************************************************/
  191. BOOL APIENTRY FontProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
  192. {
  193.   BOOL b ;
  194.   TCHAR szNum[30] ;
  196.   switch (msg)
  197.   {
  198.     case WM_INITDIALOG:
  200.         InitLogFontStruct(hwnd, &lf) ;   //fill (struct lf) so the choosefont
  201.         InitFontStruct(hwnd, &cf) ;      //struct can use it
  202.         FillFontDlg(hwnd, &cf) ;
  204.         CheckRadioButton(hwnd, ID_HDCSCREEN, ID_HDCPRINTER, ID_HDCSCREEN) ;
  205.         nHdcType = HDCSCREEN ;
  207.         dwFontFlag = cf.Flags ;
  209.         FillFontsBox(hwnd, dwFontFlag) ;
  211.         ResetCheckBoxes(hwnd) ;
  213.         *(&cfThread1) = *(&cfThread2) = *(&cf) ;
  215.         hwndMainFont = hwnd ;
  216.         nOpenFontDialogCount = 0 ;
  218.         SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEF)) ;
  220.         break ;
  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.
  229.       nOpenFontDialogCount-- ;
  231.       if (nOpenFontDialogCount == 0)
  232.         EnableFontButtons(hwnd, TRUE) ;
  234.       break ;
  237.     case WM_CF_LF:
  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 */
  246.        SendMessage((HWND) lParam, WM_CHOOSEFONT_GETLOGFONT,
  247.                    0, (LPARAM) &lfWM_CF_LF) ;
  249.        bLogFontParam = TRUE ; //tells us if we are doing normal logfont
  250.                               //processing or answering the WM_CF_LF message.
  252.        DialogBoxParam(hInst, MAKEINTRESOURCE(ID_LOGFONTDIALOG),
  253.                       (HWND) lParam, LogFontProc, (LPARAM) &lf) ;
  255.        bLogFontParam = FALSE ;
  257.        break ;
  260.     case WM_COMMAND:
  261.     {
  262.         switch (LOWORD(wParam))
  263.         {
  264.           case IDOK:
  265.             DoChooseFontStuff(hwnd, &cf) ;  //create the dialog.
  266.             break ;
  268.           case IDCANCEL:
  269.             EndDialog(hwnd, FALSE) ;
  270.             break ;
  272.           case ID_RESETFONT:
  274.             InitLogFontStruct(hwnd, &lf) ;  //reset all the structures.
  275.             InitFontStruct(hwnd, &cf) ;
  276.             FillFontDlg(hwnd, &cf) ;        //refill the dialog.
  278.             CheckRadioButton(hwnd, ID_HDCSCREEN, ID_HDCPRINTER, ID_HDCSCREEN) ;
  279.             nHdcType = HDCSCREEN ;
  281.             SendDlgItemMessage(hwnd, ID_NULLSTRUCTFONT, BM_SETCHECK, (WPARAM) 0, (LPARAM)0) ;
  282.             SendDlgItemMessage(hwnd, ID_PRELOADEDFONT,  BM_SETCHECK, (WPARAM) 0, (LPARAM)0) ;
  284.             dwFontFlag = cf.Flags ;
  285.             FillFontsBox(hwnd, dwFontFlag) ;
  286.             ResetCheckBoxes(hwnd) ;
  288.             SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEF)) ;
  290.             break ;
  293.           case ID_HDCSCREEN:
  294.             nHdcType = HDCSCREEN ;
  295.             break ;
  297.           case ID_HDCPRINTER:
  298.             nHdcType = HDCPRINTER ;
  299.             break ;
  301.           case ID_HDCNULL:
  302.             nHdcType = HDCNULL ;
  303.             break ;
  305.           case ID_HDCINVALID:
  306.             nHdcType = HDCINVALID ;
  307.             break ;
  309.           case ID_EDITLOGFONT:
  311.             /* Get the address of the logfont and then show the user what
  312.                is in it with the Logfont dialog box */
  314.             GetDlgItemText(hwnd, ID_LOGFONTF, szNum, 30) ;
  315.             cf.lpLogFont = (LPLOGFONT) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
  317.             DialogBox(hInst, MAKEINTRESOURCE(ID_LOGFONTDIALOG),
  318.                       hwnd, LogFontProc) ;
  319.             break ;
  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 ;
  335.           case ID_MULTITHREADFONT:
  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 */
  341.             nOpenFontDialogCount = 2 ;
  343.             EnableFontButtons(hwndMainFont, FALSE) ;
  345.             /* And then do the multithreading */
  347.             MultiThreadFontDlg() ;
  349.             break ;
  352.           default: break ;
  353.         }
  354.     }
  356.     default:
  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
  364.          It must be detected with an IF statement because the value
  365.          returned by RegisterWindowMessage() is not a constant
  366.       */
  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.   }
  374.   return FALSE ;
  375. }
  384. /************************************************************************
  386.   Function: InitFontStruct(HWND, LPCHOOSEFONT)
  388.   Purpose:
  390.     Fill the CHOOSEFONT structure passed as the second parameter with
  391.     some default values.
  393.   Returns: Nothing.
  395.   Comments:
  398. ************************************************************************/
  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 ;
  412.   lstrcpy(szFontTemplate, TEXT("fonttemp")) ;
  413.   pcf->lpTemplateName = szFontTemplate ;
  415.   pcf->hInstance = (HANDLE) hInst ;
  417.   lstrcpy(szFontStyle, TEXT("Bold")) ;
  418.   pcf->lpszStyle = szFontStyle ;
  420.   pcf->nFontType = SCREEN_FONTTYPE ;
  422.   pcf->nSizeMin = 8 ;
  423.   pcf->nSizeMax = 50 ;
  424. }
  435. /************************************************************************
  437.   Function: FillFontDlg(HWND, LPCHOOSEFONT)
  439.   Purpose:
  441.     Fill CDTEST's font dialog with the values in the CHOOSEFONT structure
  442.     passed via the second parameter.
  444.   Returns: Nothing.
  446.   Comments:
  449. ************************************************************************/
  451. void FillFontDlg(HWND hwnd, LPCHOOSEFONT pcf)
  452. {
  453.   wsprintf(szTemp, szLongFilter, pcf->lStructSize) ;
  454.   SetDlgItemText(hwnd, ID_STRUCTSIZEF, szTemp) ;
  456.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->hwndOwner) ;
  457.   SetDlgItemText(hwnd, ID_HWNDOWNERF, szTemp) ;
  459.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->hDC) ;
  460.   SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
  462.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->hDC) ;
  463.   SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
  465.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->lpLogFont) ;
  466.   SetDlgItemText(hwnd, ID_LOGFONTF, szTemp) ;
  468.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->iPointSize) ;
  469.   SetDlgItemText(hwnd, ID_POINTSIZEF, szTemp) ;
  471.   wsprintf(szTemp, szLongFilter, pcf->Flags) ;
  472.   SetDlgItemText(hwnd, ID_FLAGSF, szTemp) ;
  474.   wsprintf(szTemp, szLongFilter, pcf->rgbColors) ;
  475.   SetDlgItemText(hwnd, ID_RGBCOLORSF, szTemp) ;
  477.   wsprintf(szTemp, szLongFilter, pcf->lCustData) ;
  478.   SetDlgItemText(hwnd, ID_CUSTDATAF, szTemp) ;
  480.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->lpfnHook) ;
  481.   SetDlgItemText(hwnd, ID_HOOKF, szTemp) ;
  483.   SetDlgItemText(hwnd, ID_TEMPLATEF, pcf->lpTemplateName) ;
  485.   wsprintf(szTemp, szLongFilter, (DWORD) pcf->hInstance) ;
  486.   SetDlgItemText(hwnd, ID_HINSTANCEF, szTemp) ;
  488.   SetDlgItemText(hwnd, ID_STYLEF, pcf->lpszStyle) ;
  490.   wsprintf(szTemp, szLongFilter, (int) pcf->nFontType) ;
  491.   SetDlgItemText(hwnd, ID_FONTTYPEF, szTemp) ;
  493.   wsprintf(szTemp, szLongFilter, (int) pcf->nSizeMin) ;
  494.   SetDlgItemText(hwnd, ID_SIZEMINF, szTemp) ;
  496.   wsprintf(szTemp, szLongFilter, (int) pcf->nSizeMax) ;
  497.   SetDlgItemText(hwnd, ID_SIZEMAXF, szTemp) ;
  499. }
  507. /************************************************************************
  509.   Function: GetFontDlg(HWND, LPCHOOSEFONT)
  511.   Purpose:
  513.     Retrieve the users edits from CDTEST's font dialog and put them
  514.     in the CHOOSEFONT structure passed in as the second parameter
  516.   Returns: Nothing.
  518.   Comments:
  521. ************************************************************************/
  523. void GetFontDlg(HWND hwnd, LPCHOOSEFONT pcf)
  524. {
  525.   BOOL b ;
  526.   TCHAR szNum[30] ;
  528. #define WSIZEFO 30
  530.   GetDlgItemText(hwnd, ID_STRUCTSIZEF, szNum, WSIZEFO) ;
  531.   pcf->lStructSize = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  533.   GetDlgItemText(hwnd, ID_HWNDOWNERF, szNum, WSIZEFO) ;
  534.   pcf->hwndOwner = (HWND) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  536.   GetDlgItemText(hwnd, ID_LOGFONTF, szNum, WSIZEFO) ;
  537.   pcf->lpLogFont = (LPLOGFONT) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  539.   GetDlgItemText(hwnd, ID_POINTSIZEF, szNum, WSIZEFO) ;
  540.   pcf->iPointSize = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  542.   GetDlgItemText(hwnd, ID_FLAGSF, szNum, WSIZEFO) ;
  543.   pcf->Flags = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  545.   GetDlgItemText(hwnd, ID_RGBCOLORSF, szNum, WSIZEFO) ;
  546.   pcf->rgbColors = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  548.   GetDlgItemText(hwnd, ID_CUSTDATAF, szNum, WSIZEFO) ;
  549.   pcf->lCustData = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  551.   GetDlgItemText(hwnd, ID_HOOKF, szNum, WSIZEFO) ;
  552.   pcf->lpfnHook = (LPCFHOOKPROC) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  554.   GetDlgItemText(hwnd, ID_TEMPLATEF, szFontTemplate, 50) ;
  556.   GetDlgItemText(hwnd, ID_HINSTANCEF, szNum, WSIZEFO) ;
  557.   pcf->hInstance = (HANDLE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  559.   GetDlgItemText(hwnd, ID_STYLEF, szFontStyle, 50) ;
  561.   GetDlgItemText(hwnd, ID_FONTTYPEF, szNum, WSIZEFO) ;
  562.   pcf->nFontType = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  564.   GetDlgItemText(hwnd, ID_SIZEMINF, szNum, WSIZEFO) ;
  565.   pcf->nSizeMin = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  567.   GetDlgItemText(hwnd, ID_SIZEMAXF, szNum, WSIZEFO) ;
  568.   pcf->nSizeMax = (int) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  569. }
  577. /************************************************************************
  579.   Function: GetHdc(HWND, int)
  581.   Purpose:
  583.     Creates and returns an HDC of the type specified.
  586.   Returns: The HDC that it creates.
  589.   Comments:
  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.
  596.     To tell ChooseFont() to list only printer fonts:
  598.     1.  Set the HDC in CDTEST's font dialog to "Printer"
  600.     2.  Set the "Flags" edit box CF_PRINTERFONTS
  603. ************************************************************************/
  607. HDC GetHdc(HWND hwnd, int nType)
  608. {
  609.   switch (nType)
  610.   {
  611.     case HDCSCREEN:
  612.         return GetDC(hwnd) ;
  613.         break ;
  615.     case HDCNULL:
  616.         return (HDC) 0 ;
  617.         break ;
  619.     case HDCINVALID:
  620.         return (HDC) 999 ;
  621.         break ;
  623.     case HDCPRINTER:
  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. */
  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 ;
  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 ;
  648.         break ;
  650.     default:
  651.         break ;
  652.   }
  653.   return (HDC) 0 ;
  654. }
  664. /************************************************************************
  666.   Function: LogFontProc(HWND, int)
  668.   Purpose:
  670.     The callback proc for the LogFont dialog box
  673.   Returns: BOOL -- depending on the situation.
  676.   Comments:
  678. ************************************************************************/
  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 ;
  690.     case WM_COMMAND:
  691.         switch(LOWORD(wParam))
  692.         {
  693.           case IDOK:
  695.             GetLogFontDlg(hwnd, &lf) ;
  697.             cf.lpLogFont = &lf ;
  699.             EndDialog(hwnd, TRUE) ;
  701.             break ;
  705.           case ID_RESETLF:
  707.             SetFocus(GetDlgItem(hwnd, ID_LFHEIGHT)) ;
  709.             InitLogFontStruct(hwnd, &lf) ;
  711.             FillLogFontDlg(hwnd, &lf) ;
  713.             break ;
  716.           case IDCANCEL:
  718.             EndDialog(hwnd, FALSE) ;
  720.             break ;
  723.           default:
  724.             break ;
  725.         }
  727.     default: break ;
  728.   }
  731.   return FALSE ;
  732. }
  740. /************************************************************************
  742.   Function: InitLogFontStruct(HWND, LPLOGFONT)
  744.   Purpose:
  746.     Fills the LOGFONT structure passed in as the second parameter with
  747.     some default values.
  749.   Returns: Nothing.
  751.   Comments:
  753. ************************************************************************/
  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 ;
  771.   szFaceName[0] = (TCHAR) 0 ;
  772.   lstrcpy(plf->lfFaceName, szFaceName) ;
  773. }
  780. /************************************************************************
  782.   Function: FillLogFontDlg(HWND, LPLOGFONT)
  784.   Purpose:
  786.     Fills CDTEST's logfont dialog with the values in the logfont that
  787.     is passed in as the second parameter.
  789.   Returns: Nothing.
  791.   Comments:
  793. ************************************************************************/
  795. void FillLogFontDlg(HWND hwnd, LPLOGFONT plf)
  796. {
  797.   TCHAR szTemp[50] ;
  799.   LPLOGFONT pl = plf ;
  801.   if (bLogFontParam)    //Are creating this dialog in response to the
  802.     pl = &lfWM_CF_LF ;  //WM_CHOOSEFONT_GETLOGFONT message ?
  804.   if (!pl)              //Avert a ghastly exception error
  805.     return ;
  807.   wsprintf(szTemp, szLongFilter, pl->lfHeight) ;
  808.   SetDlgItemText(hwnd, ID_LFHEIGHT, szTemp) ;
  810.   wsprintf(szTemp, szLongFilter, pl->lfWidth) ;
  811.   SetDlgItemText(hwnd, ID_LFWIDTH, szTemp) ;
  813.   wsprintf(szTemp, szLongFilter, pl->lfEscapement) ;
  814.   SetDlgItemText(hwnd, ID_LFESCAPEMENT, szTemp) ;
  816.   wsprintf(szTemp, szLongFilter, pl->lfOrientation) ;
  817.   SetDlgItemText(hwnd, ID_LFORIENTATION, szTemp) ;
  819.   wsprintf(szTemp, szLongFilter, pl->lfWeight) ;
  820.   SetDlgItemText(hwnd, ID_LFWEIGHT, szTemp) ;
  822.   wsprintf(szTemp, szShortFilter, pl->lfItalic) ;
  823.   SetDlgItemText(hwnd, ID_LFITALIC, szTemp) ;
  825.   wsprintf(szTemp, szShortFilter, pl->lfUnderline) ;
  826.   SetDlgItemText(hwnd, ID_LFUNDERLINE, szTemp) ;
  828.   wsprintf(szTemp, szShortFilter, pl->lfStrikeOut) ;
  829.   SetDlgItemText(hwnd, ID_LFSTRIKEOUT, szTemp) ;
  831.   wsprintf(szTemp, szShortFilter, pl->lfCharSet) ;
  832.   SetDlgItemText(hwnd, ID_LFCHARSET, szTemp) ;
  834.   wsprintf(szTemp, szShortFilter, pl->lfOutPrecision) ;
  835.   SetDlgItemText(hwnd, ID_LFOUTP, szTemp) ;
  837.   wsprintf(szTemp, szShortFilter, pl->lfClipPrecision) ;
  838.   SetDlgItemText(hwnd, ID_LFCLIPP, szTemp) ;
  840.   wsprintf(szTemp, szShortFilter, pl->lfQuality) ;
  841.   SetDlgItemText(hwnd, ID_LFQUALITY, szTemp) ;
  843.   wsprintf(szTemp, szShortFilter, pl->lfPitchAndFamily) ;
  844.   SetDlgItemText(hwnd, ID_LFPITCHANDFAM, szTemp) ;
  846.   SetDlgItemText(hwnd, ID_LFFACENAME, (LPTSTR) pl->lfFaceName) ;
  847. }
  854. /************************************************************************
  856.   Function: GetLogFontDlg(HWND, LPLOGFONT)
  858.   Purpose:
  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.
  863.   Returns: Nothing.
  865.   Comments:
  867. ************************************************************************/
  869. void GetLogFontDlg(HWND hwnd, LPLOGFONT plf)
  870. {
  871.   BOOL b ;
  872.   TCHAR szNum[30] ;
  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...
  878.   #define LFSIZE 30
  880.   GetDlgItemText(hwnd, ID_LFHEIGHT, szNum, LFSIZE) ;
  881.   plf->lfHeight = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  883.   GetDlgItemText(hwnd, ID_LFWIDTH, szNum, LFSIZE) ;
  884.   plf->lfWidth = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  886.   GetDlgItemText(hwnd, ID_LFESCAPEMENT, szNum, LFSIZE) ;
  887.   plf->lfEscapement = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  889.   GetDlgItemText(hwnd, ID_LFORIENTATION, szNum, LFSIZE) ;
  890.   plf->lfOrientation = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  892.   GetDlgItemText(hwnd, ID_LFWEIGHT, szNum, LFSIZE) ;
  893.   plf->lfWeight = MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  895.   GetDlgItemText(hwnd, ID_LFITALIC, szNum, LFSIZE) ;
  896.   plf->lfItalic = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  898.   GetDlgItemText(hwnd, ID_LFUNDERLINE, szNum, LFSIZE) ;
  899.   plf->lfUnderline = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  901.   GetDlgItemText(hwnd, ID_LFSTRIKEOUT, szNum, LFSIZE) ;
  902.   plf->lfStrikeOut = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  904.   GetDlgItemText(hwnd, ID_LFCHARSET, szNum, LFSIZE) ;
  905.   plf->lfCharSet = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  907.   GetDlgItemText(hwnd, ID_LFOUTP, szNum, LFSIZE) ;
  908.   plf->lfOutPrecision = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  910.   GetDlgItemText(hwnd, ID_LFCLIPP, szNum, LFSIZE) ;
  911.   plf->lfClipPrecision = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  913.   GetDlgItemText(hwnd, ID_LFQUALITY, szNum, LFSIZE) ;
  914.   plf->lfQuality = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  916.   GetDlgItemText(hwnd, ID_LFPITCHANDFAM, szNum, LFSIZE) ;
  917.   plf->lfPitchAndFamily = (BYTE) MyAtol(szNum, uMode == IDM_HEXMODE, &b) ;
  919.   GetDlgItemText(hwnd, ID_LFFACENAME, (LPTSTR) plf->lfFaceName, 32) ;
  920. }
  929. /************************************************************************
  931.   Function: FontHookProc(HWND, UINT, UINT, LONG)
  933.   Purpose: The callback function that acts as the hook proc for
  934.            the ChooseFont() dialog.
  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.
  941.   Comments:
  943. ************************************************************************/
  945. UINT APIENTRY FontHookProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
  946. {
  947.   LPCHOOSEFONT pCf ;
  948.   TCHAR szMsg[50] ;
  950.   switch(msg)
  951.   {
  952.     case WM_INITDIALOG:
  954.       pCf = (LPCHOOSEFONT) lParam ;
  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.       }
  962.       SetWindowText(hwnd, TEXT("Font Hook Proc Dialog")) ;
  964.       break ;
  966.     case WM_COMMAND:
  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.
  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:
  976.            1.  Enter (CF_ENABLEHOOK | CF_ENABLETEMPLATE | CF_SCREENFONTS)
  977.                in the "Flags" edit box of CDTEST'S Font dialog.
  979.            2.  Click OK
  980.         */
  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 */
  987.         if (LOWORD(wParam) == ID_SEND_WM_CF_LF_MSG)
  988.           SendMessage(GetParent(hwnd), WM_CF_LF, 0, (LPARAM) hwnd) ;
  990.         break ;
  993.     default:
  994.       break ;
  995.   }
  997.   return FALSE ;   //send msg to the common dialog code
  998. }
  1008. /************************************************************************
  1010.   Function: GetFontDlgHandle(void)
  1012.   Purpose:  Finds and loads the custom template resource and returns a
  1013.             handle to it.
  1016.   Returns: A handle to the custom template resource.
  1018.   Comments:
  1020. ************************************************************************/
  1022. HANDLE GetFontDlgHandle(void)
  1023. {
  1025.   hResFont = FindResource(hInst, TEXT("fonttemp"), RT_DIALOG) ;
  1027.   hDialogFont = LoadResource(hInst, hResFont) ;
  1030.   return hDialogFont ;
  1031. }
  1040. /************************************************************************
  1042.   Function: EnumFontsProc(LPLOGFONT, LPTEXTMETRIC, DWORD, LONG)
  1044.   Purpose: Acts as a callback function for the EnumFontFamilies()
  1045.            function.
  1047.   Returns: 0 if the font enumeration should stop.  1 to ask for the
  1048.            next font.
  1050.   Comments:
  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.
  1059.     NOTE:
  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.
  1065.     The fonts found with this function should be the same as the ones
  1066.     found by ChooseFont() for any flag combination.
  1069. ************************************************************************/
  1072. int CALLBACK EnumFontsProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
  1073.                            DWORD dwStyle, LONG lParam)
  1074. {
  1075.   UINT i ;
  1077.   /* check to see if the font is already there right off the bat
  1078.      and just continue the enumeration if it is...        */
  1081.   i = SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_FINDSTRINGEXACT, (WPARAM) 0,
  1082.                          (LONG) (LPTSTR) lplf->lfFaceName) ;
  1084.   if (i != LB_ERR)
  1085.   {
  1086.     if (bScreen)     //if we are adding it for the first time
  1087.       return 1 ;
  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...
  1092.     else
  1093.     {
  1094.       SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_SETITEMDATA, i,
  1095.                           FONT_TYPE_WYSIWYG) ;
  1096.       return 1 ;
  1097.     }
  1098.   }
  1101.   //Get rid of any fonts that we don't want...
  1103.   if ((dwFontFlag & CF_TTONLY) && (!(dwStyle & TRUETYPE_FONTTYPE)))
  1104.     return 1 ;
  1106.   if ((dwFontFlag & CF_SCALABLEONLY) && (dwStyle & RASTER_FONTTYPE))
  1107.     return 1 ;
  1109.   if ((dwFontFlag & CF_ANSIONLY) && (lplf->lfCharSet != ANSI_CHARSET))
  1110.     return 1 ;
  1112.   if ((dwFontFlag & CF_FIXEDPITCHONLY) && (lplf->lfPitchAndFamily & VARIABLE_PITCH))
  1113.     return 1 ;
  1115.   if ((dwFontFlag & CF_NOVECTORFONTS) && (lplf->lfCharSet == OEM_CHARSET))
  1116.     return 1 ;
  1119.   //if there is a font to be added, add it.
  1121.   if (*(lplf->lfFaceName))
  1122.     SendDlgItemMessage((HWND) lParam, ID_FONTLIST, LB_ADDSTRING,
  1123.                      (WPARAM) 0, (LONG) (LPTSTR) lplf->lfFaceName) ;
  1125.   return 1 ;
  1126. }
  1135. /************************************************************************
  1137.   Function: FillFontsBox(HWND, DWORD)
  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).
  1143.   Returns: Nothing.
  1145.   Comments:
  1148. ************************************************************************/
  1150. void FillFontsBox(HWND hwnd, DWORD dwFlags)
  1151. {
  1152.   HDC hdc ;
  1153.   HWND hwndControl ;
  1154.   DWORD dwData ;
  1155.   int nItemCount ;
  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. */
  1162.   SendDlgItemMessage(hwnd, ID_FONTLIST, LB_RESETCONTENT, (WPARAM)0, (LPARAM) 0) ;
  1164.   hwndControl = GetDlgItem(hwnd, ID_FONTLIST) ;
  1166.   SendMessage(hwndControl, WM_SETREDRAW, FALSE, 0L) ;
  1169.   /* Now call EnumFontFamilies() for each type of HDC requested */
  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.   }
  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.   }
  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. */
  1192.   if (dwFontFlag & CF_WYSIWYG)
  1193.   {
  1194.     nItemCount = SendDlgItemMessage(hwnd, ID_FONTLIST, LB_GETCOUNT, 0, 0L) ;
  1196.     nItemCount-- ;   //the list is zero based
  1198.     while (nItemCount >= 0)
  1199.     {
  1200.       dwData = SendDlgItemMessage(hwnd, ID_FONTLIST, LB_GETITEMDATA, nItemCount, 0L) ;
  1202.       if (dwData != FONT_TYPE_WYSIWYG)
  1203.       {
  1204.         SendDlgItemMessage(hwnd, ID_FONTLIST, LB_DELETESTRING, nItemCount, 0L) ;
  1205.       }
  1207.       nItemCount-- ;
  1208.     }
  1209.   }
  1212.   /* Now redraw the font list */
  1214.   SendMessage(hwndControl, WM_SETREDRAW, TRUE, 0L) ;
  1215.   InvalidateRect(hwndControl, NULL, FALSE) ;
  1217.   return ;
  1218. }
  1225. /************************************************************************
  1227.   Function: ResetCheckBoxes(HWND)
  1229.   Purpose: Checks the checkboxes that control what fonts are listed in
  1230.            CDTEST's font list box.
  1232.   Returns: Nothing.
  1234.   Comments:
  1237. ************************************************************************/
  1239. void ResetCheckBoxes(HWND hwnd)
  1240. {
  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) ;
  1252. }
  1259. /************************************************************************
  1261.   Function: HandleFontCheckBox(HWND)
  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.
  1270.   Returns: Nothing.
  1272.   Comments:
  1274.     CF_NOOEMFONTS and CF_NOVECTORFONTS are identical.
  1277. ************************************************************************/
  1279. void HandleFontCheckBox(HWND hwnd, int nID)
  1280. {
  1281.   DWORD dwTemp ;
  1283.   dwTemp = dwFontFlag ;
  1285.   switch (nID)
  1286.   {
  1287.     case F_TTONLY:
  1289.       /* TTONLY is a special case.  If we only want Truetype fonts,
  1290.          turn off irrelevant flags */
  1292.       if (!(dwFontFlag & CF_TTONLY)) //if we're turning this flag on...
  1293.       {
  1294.         dwFontFlag = 0L ;  //turn everyone off but the following:
  1296.         dwFontFlag |= CF_TTONLY ;
  1298.         if (dwTemp & CF_ANSIONLY)
  1299.           dwFontFlag |= CF_ANSIONLY ;
  1301.         if (dwTemp & CF_FIXEDPITCHONLY)
  1302.           dwFontFlag |= CF_FIXEDPITCHONLY ;
  1304.         if (dwTemp & CF_SCREENFONTS)
  1305.           dwFontFlag |= CF_SCREENFONTS ;
  1307.         if (dwTemp & CF_PRINTERFONTS)
  1308.           dwFontFlag |= CF_PRINTERFONTS ;
  1309.       }
  1310.       else
  1311.       {
  1312.         dwFontFlag ^= CF_TTONLY ;
  1313.       }
  1316.       break ;
  1318.     case F_ANSIONLY:
  1319.       dwFontFlag ^= CF_ANSIONLY ;        //otherwise toggle the bit.
  1320.       dwFontFlag &= ~CF_WYSIWYG ;
  1322.       break ;
  1324.     case F_PRINTERFONTS:
  1325.       dwFontFlag ^= CF_PRINTERFONTS ;
  1327.       break ;
  1329.     case F_SCREENFONTS:
  1330.       dwFontFlag ^= CF_SCREENFONTS ;
  1332.       break ;
  1334.     case F_FIXEDPITCHONLY:
  1335.       dwFontFlag ^= CF_FIXEDPITCHONLY ;
  1337.       break ;
  1339.     case F_NOOEMFONTS:
  1340.       dwFontFlag ^= CF_NOOEMFONTS ;
  1342.       break ;
  1344.     case F_NOVECTORFONTS:
  1345.       dwFontFlag ^= CF_NOVECTORFONTS ;
  1347.       break ;
  1349.     case F_SCALABLEONLY:
  1350.       dwFontFlag ^= CF_SCALABLEONLY ;
  1352.       break ;
  1354.     case F_WYSIWYG:                        //We want fonts for both the
  1355.                                            //screen and the printer...
  1356.       dwFontFlag ^= CF_WYSIWYG ;
  1358.       if (dwFontFlag & CF_WYSIWYG)
  1359.         dwFontFlag |= (CF_SCREENFONTS | CF_PRINTERFONTS | CF_SCALABLEONLY) ;
  1361.       break ;
  1363.     default: break ;
  1364.   }
  1366.   ResetCheckBoxes(hwnd) ;
  1367.   FillFontsBox(hwnd, dwFontFlag) ;
  1368. }
  1376. /************************************************************************
  1378.   Function: DoChooseFontStuff(HWND, LPCHOOSEFONT)
  1380.   Purpose:
  1382.     Calls the ChooseFont() function.
  1384.   Returns: Nothing.
  1386.   Comments:
  1389. ************************************************************************/
  1392. void DoChooseFontStuff(HWND hwnd, LPCHOOSEFONT pcf)
  1393. {
  1394.   BOOL bRet = FALSE ;
  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.   }
  1403.   pcf->hDC = GetHdc(hwnd, nHdcType) ;
  1405.   wsprintf(szTemp, szLongFilter, pcf->hDC) ;
  1406.   SetDlgItemText(hwnd, ID_HDCF, szTemp) ;
  1409.   GetFontDlg(hwnd, pcf) ;
  1412.   if (IsDlgButtonChecked(hwnd, ID_NULLSTRUCTFONT) == 1)
  1413.     bRet = ChooseFont((LPCHOOSEFONT)NULL) ;
  1414.   else
  1415.     bRet = ChooseFont(pcf) ;
  1417.   wsprintf(szTemp, szLongFilter, CommDlgExtendedError()) ;
  1418.   SetDlgItemText(hwnd, ID_ERRORF, szTemp) ;
  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.   }
  1426.   if (hDialogFont)
  1427.   {
  1428.     FreeResource(hDialogFont) ;
  1429.     hDialogFont = (HANDLE) 0 ;
  1430.     hResFont = (HANDLE) 0 ;
  1431.   }
  1433.   wsprintf(szTemp, szShortFilter, bRet) ;     //fill results into the Font dlg
  1434.   SetDlgItemText(hwnd, ID_RETURNF, szTemp) ;
  1436.   FillFontDlg(hwnd, pcf) ;
  1437. }
  1444. /************************************************************************
  1446.   Function: FontThreadProc1(LPDWORD)
  1448.   Purpose:
  1450.     Acts as the starting address for thread 1
  1452.   Returns: Any DWORD value.
  1454.   Comments:
  1457. ************************************************************************/
  1459. DWORD FontThreadProc1(LPDWORD pdw)
  1460. {
  1461.   DoChooseFontStuff(hwndMainFont, &cfThread1) ;
  1463.   PostMessage(hwndMainFont, UMSG_DECREMENTDLGCOUNT, 0, 0L ) ;
  1465.   return 0L ;
  1466. }
  1474. /************************************************************************
  1476.   Function: FontThreadProc2(LPDWORD)
  1478.   Purpose:
  1480.     Acts as the starting address for thread 2
  1482.   Returns: Any DWORD value.
  1484.   Comments:
  1487. ************************************************************************/
  1490. DWORD FontThreadProc2(LPDWORD pdw)
  1491. {
  1492.   DoChooseFontStuff(hwndMainFont, &cfThread2) ;
  1494.   PostMessage(hwndMainFont, UMSG_DECREMENTDLGCOUNT, 0, 0L ) ;
  1496.   return 0L ;
  1497. }
  1505. /************************************************************************
  1507.   Function: MultiThreadFontDlg(void)
  1509.   Purpose:
  1511.     Create the two threads that will in turn create two ChooseFont()
  1512.     dialogs.
  1514.   Returns: Nothing.
  1516.   Comments:
  1518.     Multithreading note:
  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.
  1525. ************************************************************************/
  1527. void MultiThreadFontDlg(void)
  1528. {
  1530.   dwFontThreadParm1 = dwFontThreadParm2 = 0L ;
  1532.   if (!(hFontThread1 = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0,
  1533.                                      (LPTHREAD_START_ROUTINE) FontThreadProc1,
  1534.                                      &dwFontThreadParm1, CREATE_SUSPENDED, &dwFontThreadID1)))
  1536.   {
  1537.     MessageBox(GetForegroundWindow(), TEXT("Error creating thread 1"), NULL,
  1538.                MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL) ;
  1540.     nOpenFontDialogCount = 0 ;
  1542.     EnableFontButtons(hwndMainFont, TRUE) ;
  1544.     return ;
  1545.   }
  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) ;
  1555.     nOpenFontDialogCount = 0 ;
  1557.     EnableFontButtons(hwndMainFont, TRUE) ;
  1559.     return ;
  1560.   }
  1562.   ResumeThread(hFontThread1) ;
  1563.   ResumeThread(hFontThread2) ;
  1565.   return ;
  1566. }
  1573. /************************************************************************
  1575.   Function: EnableFontButtons(HWND, BOOL)
  1577.   Purpose:
  1579.     Enables or disables CDTEST's font dialogs buttons based on the
  1580.     status of the second parameter.
  1583.   Returns: Nothing.
  1585.   Comments:
  1587.     This is necessary when multithreading in the case of this application.
  1589. ************************************************************************/
  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. }