git.oblomov.eu Git - wine/blob - dlls/commdlg/fontdlg.c

   1 /*
   2  * COMMDLG - Font Dialog
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <ctype.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include "windef.h"
  27 #include "winnls.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "wine/winbase16.h"
  31 #include "wine/winuser16.h"
  32 #include "heap.h"
  33 #include "commdlg.h"
  34 #include "dlgs.h"
  35 #include "wine/debug.h"
  36 #include "cderr.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
  39
  40 #include "cdlg.h"
  41
  42 static HBITMAP16 hBitmapTT = 0;
  43
  44
  45 LRESULT WINAPI FormatCharDlgProcA(HWND hDlg, UINT uMsg, WPARAM wParam,
  46                                   LPARAM lParam);
  47 LRESULT WINAPI FormatCharDlgProcW(HWND hDlg, UINT uMsg, WPARAM wParam,
  48                                   LPARAM lParam);
  49 LRESULT WINAPI FormatCharDlgProc16(HWND16 hDlg, UINT16 message, WPARAM16 wParam,
  50                                    LPARAM lParam);
  51
  52 static void FONT_LogFont16To32A( const LPLOGFONT16 font16, LPLOGFONTA font32 )
  53 {
  54     font32->lfHeight = font16->lfHeight;
  55     font32->lfWidth = font16->lfWidth;
  56     font32->lfEscapement = font16->lfEscapement;
  57     font32->lfOrientation = font16->lfOrientation;
  58     font32->lfWeight = font16->lfWeight;
  59     font32->lfItalic = font16->lfItalic;
  60     font32->lfUnderline = font16->lfUnderline;
  61     font32->lfStrikeOut = font16->lfStrikeOut;
  62     font32->lfCharSet = font16->lfCharSet;
  63     font32->lfOutPrecision = font16->lfOutPrecision;
  64     font32->lfClipPrecision = font16->lfClipPrecision;
  65     font32->lfQuality = font16->lfQuality;
  66     font32->lfPitchAndFamily = font16->lfPitchAndFamily;
  67     lstrcpynA( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
  68 }
  69
  70 static void CFn_CHOOSEFONT16to32A(LPCHOOSEFONT16 chf16, LPCHOOSEFONTA chf32a)
  71 {
  72   chf32a->lStructSize=sizeof(CHOOSEFONTA);
  73   chf32a->hwndOwner=chf16->hwndOwner;
  74   chf32a->hDC=chf16->hDC;
  75   chf32a->iPointSize=chf16->iPointSize;
  76   chf32a->Flags=chf16->Flags;
  77   chf32a->rgbColors=chf16->rgbColors;
  78   chf32a->lCustData=chf16->lCustData;
  79   chf32a->lpfnHook=NULL;
  80   chf32a->lpTemplateName=MapSL(chf16->lpTemplateName);
  81   chf32a->hInstance=chf16->hInstance;
  82   chf32a->lpszStyle=MapSL(chf16->lpszStyle);
  83   chf32a->nFontType=chf16->nFontType;
  84   chf32a->nSizeMax=chf16->nSizeMax;
  85   chf32a->nSizeMin=chf16->nSizeMin;
  86   FONT_LogFont16To32A(MapSL(chf16->lpLogFont), chf32a->lpLogFont);
  87 }
  88
  89 struct {
  90     int         mask;
  91     char        *name;
  92 } cfflags[] = {
  93 #define XX(x) { x, #x },
  94     XX(CF_SCREENFONTS)
  95     XX(CF_PRINTERFONTS)
  96     XX(CF_SHOWHELP)
  97     XX(CF_ENABLEHOOK)
  98     XX(CF_ENABLETEMPLATE)
  99     XX(CF_ENABLETEMPLATEHANDLE)
 100     XX(CF_INITTOLOGFONTSTRUCT)
 101     XX(CF_USESTYLE)
 102     XX(CF_EFFECTS)
 103     XX(CF_APPLY)
 104     XX(CF_ANSIONLY)
 105     XX(CF_NOVECTORFONTS)
 106     XX(CF_NOSIMULATIONS)
 107     XX(CF_LIMITSIZE)
 108     XX(CF_FIXEDPITCHONLY)
 109     XX(CF_WYSIWYG)
 110     XX(CF_FORCEFONTEXIST)
 111     XX(CF_SCALABLEONLY)
 112     XX(CF_TTONLY)
 113     XX(CF_NOFACESEL)
 114     XX(CF_NOSTYLESEL)
 115     XX(CF_NOSIZESEL)
 116     XX(CF_SELECTSCRIPT)
 117     XX(CF_NOSCRIPTSEL)
 118     XX(CF_NOVERTFONTS)
 119 #undef XX
 120     {0,NULL},
 121 };
 122
 123 static void
 124 _dump_cf_flags(DWORD cflags) {
 125     int i;
 126
 127     for (i=0;cfflags[i].name;i++)
 128         if (cfflags[i].mask & cflags)
 129             MESSAGE("%s|",cfflags[i].name);
 130     MESSAGE("\n");
 131 }
 132
 133
 134 /***********************************************************************
 135  *                        ChooseFont   (COMMDLG.15)
 136  */
 137 BOOL16 WINAPI ChooseFont16(LPCHOOSEFONT16 lpChFont)
 138 {
 139     HINSTANCE16 hInst;
 140     HANDLE16 hDlgTmpl16 = 0, hResource16 = 0;
 141     HGLOBAL16 hGlobal16 = 0;
 142     BOOL16 bRet = FALSE;
 143     LPCVOID template;
 144     FARPROC16 ptr;
 145     CHOOSEFONTA cf32a;
 146     LOGFONTA lf32a;
 147     LOGFONT16 *font16;
 148     SEGPTR lpTemplateName;
 149
 150     cf32a.lpLogFont=&lf32a;
 151     CFn_CHOOSEFONT16to32A(lpChFont, &cf32a);
 152
 153     TRACE("ChooseFont\n");
 154     if (!lpChFont) return FALSE;
 155
 156     if (TRACE_ON(commdlg))
 157         _dump_cf_flags(lpChFont->Flags);
 158
 159     if (lpChFont->Flags & CF_ENABLETEMPLATEHANDLE)
 160     {
 161         if (!(template = LockResource16( lpChFont->hInstance )))
 162         {
 163             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 164             return FALSE;
 165         }
 166     }
 167     else if (lpChFont->Flags & CF_ENABLETEMPLATE)
 168     {
 169         HANDLE16 hResInfo;
 170         if (!(hResInfo = FindResource16( lpChFont->hInstance,
 171                                          MapSL(lpChFont->lpTemplateName),
 172                                          RT_DIALOGA)))
 173         {
 174             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 175             return FALSE;
 176         }
 177         if (!(hDlgTmpl16 = LoadResource16( lpChFont->hInstance, hResInfo )) ||
 178             !(template = LockResource16( hDlgTmpl16 )))
 179         {
 180             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 181             return FALSE;
 182         }
 183     }
 184     else
 185     {
 186         HANDLE hResInfo, hDlgTmpl32;
 187         LPCVOID template32;
 188         DWORD size;
 189         if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "CHOOSE_FONT", RT_DIALOGA)))
 190         {
 191             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 192             return FALSE;
 193         }
 194         if (!(hDlgTmpl32 = LoadResource(COMMDLG_hInstance32, hResInfo)) ||
 195             !(template32 = LockResource(hDlgTmpl32)))
 196         {
 197             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 198             return FALSE;
 199         }
 200         size = SizeofResource(GetModuleHandleA("COMDLG32"), hResInfo);
 201         hGlobal16 = GlobalAlloc16(0, size);
 202         if (!hGlobal16)
 203         {
 204             COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
 205             ERR("alloc failure for %ld bytes\n", size);
 206             return FALSE;
 207         }
 208         template = GlobalLock16(hGlobal16);
 209         if (!template)
 210         {
 211             COMDLG32_SetCommDlgExtendedError(CDERR_MEMLOCKFAILURE);
 212             ERR("global lock failure for %x handle\n", hGlobal16);
 213             GlobalFree16(hGlobal16);
 214             return FALSE;
 215         }
 216         ConvertDialog32To16((LPVOID)template32, size, (LPVOID)template);
 217         hDlgTmpl16 = hGlobal16;
 218
 219     }
 220
 221     /* lpTemplateName is not used in the dialog */
 222     lpTemplateName=lpChFont->lpTemplateName;
 223     lpChFont->lpTemplateName=(SEGPTR)&cf32a;
 224
 225     ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 16);
 226     hInst = GetWindowLongA(lpChFont->hwndOwner, GWL_HINSTANCE);
 227     bRet = DialogBoxIndirectParam16(hInst, hDlgTmpl16, lpChFont->hwndOwner,
 228                      (DLGPROC16) ptr, (DWORD)lpChFont);
 229     if (hResource16) FreeResource16(hDlgTmpl16);
 230     if (hGlobal16)
 231     {
 232         GlobalUnlock16(hGlobal16);
 233         GlobalFree16(hGlobal16);
 234     }
 235     lpChFont->lpTemplateName=lpTemplateName;
 236
 237
 238     font16 = MapSL(lpChFont->lpLogFont);
 239     font16->lfHeight = cf32a.lpLogFont->lfHeight;
 240     font16->lfWidth = cf32a.lpLogFont->lfWidth;
 241     font16->lfEscapement = cf32a.lpLogFont->lfEscapement;
 242     font16->lfOrientation = cf32a.lpLogFont->lfOrientation;
 243     font16->lfWeight = cf32a.lpLogFont->lfWeight;
 244     font16->lfItalic = cf32a.lpLogFont->lfItalic;
 245     font16->lfUnderline = cf32a.lpLogFont->lfUnderline;
 246     font16->lfStrikeOut = cf32a.lpLogFont->lfStrikeOut;
 247     font16->lfCharSet = cf32a.lpLogFont->lfCharSet;
 248     font16->lfOutPrecision = cf32a.lpLogFont->lfOutPrecision;
 249     font16->lfClipPrecision = cf32a.lpLogFont->lfClipPrecision;
 250     font16->lfQuality = cf32a.lpLogFont->lfQuality;
 251     font16->lfPitchAndFamily = cf32a.lpLogFont->lfPitchAndFamily;
 252     lstrcpynA( font16->lfFaceName, cf32a.lpLogFont->lfFaceName, LF_FACESIZE );
 253     return bRet;
 254 }
 255
 256
 257 /***********************************************************************
 258  *           ChooseFontA   (COMDLG32.@)
 259  */
 260 BOOL WINAPI ChooseFontA(LPCHOOSEFONTA lpChFont)
 261 {
 262   LPCVOID template;
 263   HANDLE hResInfo, hDlgTmpl;
 264
 265   if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "CHOOSE_FONT", RT_DIALOGA)))
 266   {
 267     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 268     return FALSE;
 269   }
 270   if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 271       !(template = LockResource( hDlgTmpl )))
 272   {
 273     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 274     return FALSE;
 275   }
 276   if (TRACE_ON(commdlg))
 277         _dump_cf_flags(lpChFont->Flags);
 278
 279   if (lpChFont->Flags & (CF_SELECTSCRIPT | CF_NOVERTFONTS | CF_ENABLETEMPLATE |
 280     CF_ENABLETEMPLATEHANDLE)) FIXME(": unimplemented flag (ignored)\n");
 281   return DialogBoxIndirectParamA(COMMDLG_hInstance32, template,
 282             lpChFont->hwndOwner, (DLGPROC)FormatCharDlgProcA, (LPARAM)lpChFont );
 283 }
 284
 285 /***********************************************************************
 286  *           ChooseFontW   (COMDLG32.@)
 287  *
 288  *  NOTES:
 289  *
 290  *      The LOGFONT conversion functions will break if the structure ever
 291  *      grows beyond the lfFaceName element.
 292  *
 293  *      The CHOOSEFONT conversion functions assume that both versions of
 294  *      lpLogFont and lpszStyle (if used) point to pre-allocated objects.
 295  *
 296  *      The ASCII version of lpTemplateName is created by ChooseFontAtoW
 297  *      and freed by ChooseFontWtoA.
 298  */
 299 inline static VOID LogFontWtoA(const LOGFONTW *lfw, LOGFONTA *lfa)
 300 {
 301     memcpy(lfa, lfw, sizeof(LOGFONTA));
 302     WideCharToMultiByte(CP_ACP, 0, lfw->lfFaceName, -1, lfa->lfFaceName,
 303             LF_FACESIZE, NULL, NULL);
 304     lfa->lfFaceName[LF_FACESIZE - 1] = '\0';
 305 }
 306
 307 inline static VOID LogFontAtoW(const LOGFONTA *lfa, LOGFONTW *lfw)
 308 {
 309     memcpy(lfw, lfa, sizeof(LOGFONTA));
 310     MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw->lfFaceName,
 311             LF_FACESIZE);
 312     lfw->lfFaceName[LF_FACESIZE - 1] = 0;
 313 }
 314
 315 static BOOL ChooseFontWtoA(const CHOOSEFONTW *cfw, CHOOSEFONTA *cfa)
 316 {
 317     LOGFONTA    *lpLogFont = cfa->lpLogFont;
 318     LPSTR       lpszStyle = cfa->lpszStyle;
 319
 320     memcpy(cfa, cfw, sizeof(CHOOSEFONTA));
 321     cfa->lpLogFont = lpLogFont;
 322     cfa->lpszStyle = lpszStyle;
 323
 324     LogFontWtoA(cfw->lpLogFont, lpLogFont);
 325
 326     if (cfw->lpTemplateName != NULL)
 327     {
 328         cfa->lpTemplateName = HEAP_strdupWtoA(GetProcessHeap(), 0,
 329                 cfw->lpTemplateName);
 330         if (cfa->lpTemplateName == NULL)
 331             return FALSE;
 332     }
 333
 334     if ((cfw->Flags & CF_USESTYLE) != 0 && cfw->lpszStyle != NULL)
 335     {
 336         WideCharToMultiByte(CP_ACP, 0, cfw->lpszStyle, -1, cfa->lpszStyle,
 337                 LF_FACESIZE, NULL, NULL);
 338         cfa->lpszStyle[LF_FACESIZE - 1] = '\0';
 339     }
 340
 341     return TRUE;
 342 }
 343
 344 static VOID ChooseFontAtoW(const CHOOSEFONTA *cfa, CHOOSEFONTW *cfw)
 345 {
 346     LOGFONTW    *lpLogFont = cfw->lpLogFont;
 347     LPWSTR      lpszStyle = cfw->lpszStyle;
 348     LPCWSTR     lpTemplateName = cfw->lpTemplateName;
 349
 350     memcpy(cfw, cfa, sizeof(CHOOSEFONTA));
 351     cfw->lpLogFont = lpLogFont;
 352     cfw->lpszStyle = lpszStyle;
 353     cfw->lpTemplateName = lpTemplateName;
 354
 355     LogFontAtoW(cfa->lpLogFont, lpLogFont);
 356
 357     if (cfa->lpTemplateName != NULL)
 358         HeapFree(GetProcessHeap(), 0, (LPSTR)(cfa->lpTemplateName));
 359
 360     if ((cfa->Flags & CF_USESTYLE) != 0 && cfa->lpszStyle != NULL)
 361     {
 362         MultiByteToWideChar(CP_ACP, 0, cfa->lpszStyle, -1, cfw->lpszStyle,
 363                 LF_FACESIZE);
 364         cfw->lpszStyle[LF_FACESIZE - 1] = 0;
 365     }
 366 }
 367
 368 BOOL WINAPI ChooseFontW(LPCHOOSEFONTW lpChFont)
 369 {
 370     CHOOSEFONTA     cf_a;
 371     LOGFONTA        lf_a;
 372     CHAR            style_a[LF_FACESIZE];
 373
 374     cf_a.lpLogFont = &lf_a;
 375     cf_a.lpszStyle = style_a;
 376
 377     if (ChooseFontWtoA(lpChFont, &cf_a) == FALSE)
 378     {
 379         COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
 380         return FALSE;
 381     }
 382
 383     if (ChooseFontA(&cf_a) == FALSE)
 384     {
 385         if (cf_a.lpTemplateName != NULL)
 386             HeapFree(GetProcessHeap(), 0, (LPSTR)(cf_a.lpTemplateName));
 387         return FALSE;
 388     }
 389
 390     ChooseFontAtoW(&cf_a, lpChFont);
 391
 392     return TRUE;
 393 }
 394
 395 #if 0
 396 /***********************************************************************
 397  *           ChooseFontW   (COMDLG32.@)
 398  */
 399 BOOL WINAPI ChooseFontW(LPCHOOSEFONTW lpChFont)
 400 {
 401   BOOL bRet=FALSE;
 402   CHOOSEFONTA cf32a;
 403   LOGFONTA lf32a;
 404   LPCVOID template;
 405   HANDLE hResInfo, hDlgTmpl;
 406
 407   if (TRACE_ON(commdlg))
 408         _dump_cf_flags(lpChFont->Flags);
 409
 410   if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "CHOOSE_FONT", RT_DIALOGA)))
 411   {
 412     COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 413     return FALSE;
 414   }
 415   if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
 416       !(template = LockResource( hDlgTmpl )))
 417   {
 418     COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 419     return FALSE;
 420   }
 421
 422   if (lpChFont->Flags & (CF_SELECTSCRIPT | CF_NOVERTFONTS | CF_ENABLETEMPLATE |
 423     CF_ENABLETEMPLATEHANDLE)) FIXME(": unimplemented flag (ignored)\n");
 424   memcpy(&cf32a, lpChFont, sizeof(cf32a));
 425   memcpy(&lf32a, lpChFont->lpLogFont, sizeof(LOGFONTA));
 426
 427   WideCharToMultiByte( CP_ACP, 0, lpChFont->lpLogFont->lfFaceName, -1,
 428                        lf32a.lfFaceName, LF_FACESIZE, NULL, NULL );
 429   lf32a.lfFaceName[LF_FACESIZE-1] = 0;
 430   cf32a.lpLogFont=&lf32a;
 431   cf32a.lpszStyle=HEAP_strdupWtoA(GetProcessHeap(), 0, lpChFont->lpszStyle);
 432   lpChFont->lpTemplateName=(LPWSTR)&cf32a;
 433   bRet = DialogBoxIndirectParamW(COMMDLG_hInstance32, template,
 434             lpChFont->hwndOwner, (DLGPROC)FormatCharDlgProcW, (LPARAM)lpChFont );
 435   HeapFree(GetProcessHeap(), 0, cf32a.lpszStyle);
 436   lpChFont->lpTemplateName=(LPWSTR)cf32a.lpTemplateName;
 437   memcpy(lpChFont->lpLogFont, &lf32a, sizeof(CHOOSEFONTA));
 438   MultiByteToWideChar( CP_ACP, 0, lf32a.lfFaceName, -1,
 439                        lpChFont->lpLogFont->lfFaceName, LF_FACESIZE );
 440   lpChFont->lpLogFont->lfFaceName[LF_FACESIZE-1] = 0;
 441   return bRet;
 442 }
 443 #endif
 444
 445 #define TEXT_EXTRAS 4
 446 #define TEXT_COLORS 16
 447
 448 static const COLORREF textcolors[TEXT_COLORS]=
 449 {
 450  0x00000000L,0x00000080L,0x00008000L,0x00008080L,
 451  0x00800000L,0x00800080L,0x00808000L,0x00808080L,
 452  0x00c0c0c0L,0x000000ffL,0x0000ff00L,0x0000ffffL,
 453  0x00ff0000L,0x00ff00ffL,0x00ffff00L,0x00FFFFFFL
 454 };
 455
 456 /***********************************************************************
 457  *                          CFn_HookCallChk                 [internal]
 458  */
 459 static BOOL CFn_HookCallChk(LPCHOOSEFONT16 lpcf)
 460 {
 461  if (lpcf)
 462   if(lpcf->Flags & CF_ENABLEHOOK)
 463    if (lpcf->lpfnHook)
 464     return TRUE;
 465  return FALSE;
 466 }
 467
 468 /***********************************************************************
 469  *                          CFn_HookCallChk32                 [internal]
 470  */
 471 static BOOL CFn_HookCallChk32(LPCHOOSEFONTA lpcf)
 472 {
 473  if (lpcf)
 474   if(lpcf->Flags & CF_ENABLEHOOK)
 475    if (lpcf->lpfnHook)
 476     return TRUE;
 477  return FALSE;
 478 }
 479
 480 typedef struct
 481 {
 482   HWND hWnd1;
 483   HWND hWnd2;
 484   LPCHOOSEFONTA lpcf32a;
 485   int  added;
 486 } CFn_ENUMSTRUCT, *LPCFn_ENUMSTRUCT;
 487
 488 /*************************************************************************
 489  *              AddFontFamily                               [internal]
 490  */
 491 static INT AddFontFamily(const LOGFONTA *lplf, UINT nFontType,
 492                            LPCHOOSEFONTA lpcf, HWND hwnd, LPCFn_ENUMSTRUCT e)
 493 {
 494   int i;
 495   WORD w;
 496
 497   TRACE("font=%s (nFontType=%d)\n", lplf->lfFaceName,nFontType);
 498
 499   if (lpcf->Flags & CF_FIXEDPITCHONLY)
 500    if (!(lplf->lfPitchAndFamily & FIXED_PITCH))
 501      return 1;
 502   if (lpcf->Flags & CF_ANSIONLY)
 503    if (lplf->lfCharSet != ANSI_CHARSET)
 504      return 1;
 505   if (lpcf->Flags & CF_TTONLY)
 506    if (!(nFontType & TRUETYPE_FONTTYPE))
 507      return 1;
 508
 509   if (e) e->added++;
 510
 511   i=SendMessageA(hwnd, CB_ADDSTRING, 0, (LPARAM)lplf->lfFaceName);
 512   if (i!=CB_ERR)
 513   {
 514     w=(lplf->lfCharSet << 8) | lplf->lfPitchAndFamily;
 515     SendMessageA(hwnd, CB_SETITEMDATA, i, MAKELONG(nFontType,w));
 516     return 1 ;        /* store some important font information */
 517   }
 518   else
 519     return 0;
 520 }
 521
 522 /*************************************************************************
 523  *              FontFamilyEnumProc32                           [internal]
 524  */
 525 static INT WINAPI FontFamilyEnumProc(const LOGFONTA *lpLogFont,
 526           const TEXTMETRICA *metrics, DWORD dwFontType, LPARAM lParam)
 527 {
 528   LPCFn_ENUMSTRUCT e;
 529   e=(LPCFn_ENUMSTRUCT)lParam;
 530   return AddFontFamily(lpLogFont, dwFontType, e->lpcf32a, e->hWnd1, e);
 531 }
 532
 533 /***********************************************************************
 534  *                FontFamilyEnumProc                     (COMMDLG.19)
 535  */
 536 INT16 WINAPI FontFamilyEnumProc16( SEGPTR logfont, SEGPTR metrics,
 537                                    UINT16 nFontType, LPARAM lParam )
 538 {
 539   HWND16 hwnd=LOWORD(lParam);
 540   HWND hDlg=GetParent(hwnd);
 541   LPCHOOSEFONT16 lpcf=(LPCHOOSEFONT16)GetWindowLongA(hDlg, DWL_USER);
 542   LOGFONT16 *lplf = MapSL( logfont );
 543   LOGFONTA lf32a;
 544   FONT_LogFont16To32A(lplf, &lf32a);
 545   return AddFontFamily(&lf32a, nFontType, (LPCHOOSEFONTA)lpcf->lpTemplateName,
 546                        hwnd,NULL);
 547 }
 548
 549 /*************************************************************************
 550  *              SetFontStylesToCombo2                           [internal]
 551  *
 552  * Fill font style information into combobox  (without using font.c directly)
 553  */
 554 static int SetFontStylesToCombo2(HWND hwnd, HDC hdc, const LOGFONTA *lplf)
 555 {
 556    #define FSTYLES 4
 557    struct FONTSTYLE
 558           { int italic;
 559             int weight;
 560             char stname[20]; };
 561    static struct FONTSTYLE fontstyles[FSTYLES]={
 562           { 0,FW_NORMAL,"Regular"},{0,FW_BOLD,"Bold"},
 563           { 1,FW_NORMAL,"Italic"}, {1,FW_BOLD,"Bold Italic"}};
 564    HFONT hf;
 565    TEXTMETRICA tm;
 566    int i,j;
 567    LOGFONTA lf;
 568
 569    memcpy(&lf, lplf, sizeof(LOGFONTA));
 570
 571    for (i=0;i<FSTYLES;i++)
 572    {
 573      lf.lfItalic=fontstyles[i].italic;
 574      lf.lfWeight=fontstyles[i].weight;
 575      hf=CreateFontIndirectA(&lf);
 576      hf=SelectObject(hdc,hf);
 577      GetTextMetricsA(hdc,&tm);
 578      hf=SelectObject(hdc,hf);
 579      DeleteObject(hf);
 580
 581      if (tm.tmWeight==fontstyles[i].weight &&
 582          tm.tmItalic==fontstyles[i].italic)    /* font successful created ? */
 583      {
 584        j=SendMessageA(hwnd,CB_ADDSTRING,0,(LPARAM)fontstyles[i].stname );
 585        if (j==CB_ERR) return 1;
 586        j=SendMessageA(hwnd, CB_SETITEMDATA, j,
 587                                  MAKELONG(fontstyles[i].weight,fontstyles[i].italic));
 588        if (j==CB_ERR) return 1;
 589      }
 590    }
 591   return 0;
 592 }
 593
 594 /*************************************************************************
 595  *              AddFontSizeToCombo3                           [internal]
 596  */
 597 static int AddFontSizeToCombo3(HWND hwnd, UINT h, LPCHOOSEFONTA lpcf)
 598 {
 599     int j;
 600     char buffer[20];
 601
 602     if (  (!(lpcf->Flags & CF_LIMITSIZE))  ||
 603         ((lpcf->Flags & CF_LIMITSIZE) && (h >= lpcf->nSizeMin) && (h <= lpcf->nSizeMax)))
 604     {
 605         sprintf(buffer, "%2d", h);
 606         j=SendMessageA(hwnd, CB_FINDSTRINGEXACT, -1, (LPARAM)buffer);
 607         if (j==CB_ERR)
 608         {
 609             j=SendMessageA(hwnd, CB_ADDSTRING, 0, (LPARAM)buffer);
 610             if (j!=CB_ERR) j = SendMessageA(hwnd, CB_SETITEMDATA, j, h);
 611             if (j==CB_ERR) return 1;
 612         }
 613     }
 614     return 0;
 615 }
 616
 617 /*************************************************************************
 618  *              SetFontSizesToCombo3                           [internal]
 619  */
 620 static int SetFontSizesToCombo3(HWND hwnd, LPCHOOSEFONTA lpcf)
 621 {
 622   static const int sizes[]={8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72,0};
 623   int i;
 624
 625   for (i=0; sizes[i]; i++)
 626     if (AddFontSizeToCombo3(hwnd, sizes[i], lpcf)) return 1;
 627   return 0;
 628 }
 629
 630 /***********************************************************************
 631  *                 AddFontStyle                          [internal]
 632  */
 633 static INT AddFontStyle(const LOGFONTA *lplf, UINT nFontType,
 634     LPCHOOSEFONTA lpcf, HWND hcmb2, HWND hcmb3, HWND hDlg)
 635 {
 636   int i;
 637
 638   TRACE("(nFontType=%d)\n",nFontType);
 639   TRACE("  %s h=%ld w=%ld e=%ld o=%ld wg=%ld i=%d u=%d s=%d"
 640                " ch=%d op=%d cp=%d q=%d pf=%xh\n",
 641                lplf->lfFaceName,lplf->lfHeight,lplf->lfWidth,
 642                lplf->lfEscapement,lplf->lfOrientation,
 643                lplf->lfWeight,lplf->lfItalic,lplf->lfUnderline,
 644                lplf->lfStrikeOut,lplf->lfCharSet, lplf->lfOutPrecision,
 645                lplf->lfClipPrecision,lplf->lfQuality, lplf->lfPitchAndFamily);
 646   if (nFontType & RASTER_FONTTYPE)
 647   {
 648     if (AddFontSizeToCombo3(hcmb3, lplf->lfHeight, lpcf)) return 0;
 649   } else if (SetFontSizesToCombo3(hcmb3, lpcf)) return 0;
 650
 651   if (!SendMessageA(hcmb2, CB_GETCOUNT, 0, 0))
 652   {
 653        HDC hdc= ((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC) ? lpcf->hDC : GetDC(hDlg);
 654        i=SetFontStylesToCombo2(hcmb2,hdc,lplf);
 655        if (!((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC))
 656          ReleaseDC(hDlg,hdc);
 657        if (i)
 658         return 0;
 659   }
 660   return 1 ;
 661
 662 }
 663
 664 /***********************************************************************
 665  *                 FontStyleEnumProc                     (COMMDLG.18)
 666  */
 667 INT16 WINAPI FontStyleEnumProc16( SEGPTR logfont, SEGPTR metrics,
 668                                   UINT16 nFontType, LPARAM lParam )
 669 {
 670   HWND16 hcmb2=LOWORD(lParam);
 671   HWND16 hcmb3=HIWORD(lParam);
 672   HWND hDlg=GetParent(hcmb3);
 673   LPCHOOSEFONT16 lpcf=(LPCHOOSEFONT16)GetWindowLongA(hDlg, DWL_USER);
 674   LOGFONT16 *lplf = MapSL(logfont);
 675   LOGFONTA lf32a;
 676   FONT_LogFont16To32A(lplf, &lf32a);
 677   return AddFontStyle(&lf32a, nFontType, (LPCHOOSEFONTA)lpcf->lpTemplateName,
 678                       hcmb2, hcmb3, hDlg);
 679 }
 680
 681 /***********************************************************************
 682  *                 FontStyleEnumProc32                     [internal]
 683  */
 684 static INT WINAPI FontStyleEnumProc( const LOGFONTA *lpFont,
 685           const TEXTMETRICA *metrics, DWORD dwFontType, LPARAM lParam )
 686 {
 687   LPCFn_ENUMSTRUCT s=(LPCFn_ENUMSTRUCT)lParam;
 688   HWND hcmb2=s->hWnd1;
 689   HWND hcmb3=s->hWnd2;
 690   HWND hDlg=GetParent(hcmb3);
 691   return AddFontStyle(lpFont, dwFontType, s->lpcf32a, hcmb2,
 692                       hcmb3, hDlg);
 693 }
 694
 695 /***********************************************************************
 696  *           CFn_WMInitDialog                            [internal]
 697  */
 698 static LRESULT CFn_WMInitDialog(HWND hDlg, WPARAM wParam, LPARAM lParam,
 699                          LPCHOOSEFONTA lpcf)
 700 {
 701   HDC hdc;
 702   int i,j,res,init=0;
 703   long l;
 704   LPLOGFONTA lpxx;
 705   HCURSOR hcursor=SetCursor(LoadCursorA(0,IDC_WAITA));
 706
 707   SetWindowLongA(hDlg, DWL_USER, lParam);
 708   lpxx=lpcf->lpLogFont;
 709   TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
 710
 711   if (lpcf->lStructSize != sizeof(CHOOSEFONTA))
 712   {
 713     ERR("structure size failure !!!\n");
 714     EndDialog (hDlg, 0);
 715     return FALSE;
 716   }
 717   if (!hBitmapTT)
 718     hBitmapTT = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_TRTYPE));
 719
 720   /* This font will be deleted by WM_COMMAND */
 721   SendDlgItemMessageA(hDlg,stc6,WM_SETFONT,
 722      CreateFontA(0, 0, 1, 1, 400, 0, 0, 0, 0, 0, 0, 0, 0, NULL),FALSE);
 723
 724   if (!(lpcf->Flags & CF_SHOWHELP) || !IsWindow(lpcf->hwndOwner))
 725     ShowWindow(GetDlgItem(hDlg,pshHelp),SW_HIDE);
 726   if (!(lpcf->Flags & CF_APPLY))
 727     ShowWindow(GetDlgItem(hDlg,psh3),SW_HIDE);
 728   if (lpcf->Flags & CF_EFFECTS)
 729   {
 730     for (res=1,i=0;res && i<TEXT_COLORS;i++)
 731     {
 732       /* FIXME: load color name from resource:  res=LoadString(...,i+....,buffer,.....); */
 733       char name[20];
 734       strcpy( name, "[color name]" );
 735       j=SendDlgItemMessageA(hDlg, cmb4, CB_ADDSTRING, 0, (LPARAM)name);
 736       SendDlgItemMessageA(hDlg, cmb4, CB_SETITEMDATA16, j, textcolors[j]);
 737       /* look for a fitting value in color combobox */
 738       if (textcolors[j]==lpcf->rgbColors)
 739         SendDlgItemMessageA(hDlg,cmb4, CB_SETCURSEL,j,0);
 740     }
 741   }
 742   else
 743   {
 744     ShowWindow(GetDlgItem(hDlg,cmb4),SW_HIDE);
 745     ShowWindow(GetDlgItem(hDlg,chx1),SW_HIDE);
 746     ShowWindow(GetDlgItem(hDlg,chx2),SW_HIDE);
 747     ShowWindow(GetDlgItem(hDlg,grp1),SW_HIDE);
 748     ShowWindow(GetDlgItem(hDlg,stc4),SW_HIDE);
 749   }
 750   hdc= ((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC) ? lpcf->hDC : GetDC(hDlg);
 751   if (hdc)
 752   {
 753     CFn_ENUMSTRUCT s;
 754     s.hWnd1=GetDlgItem(hDlg,cmb1);
 755     s.lpcf32a=lpcf;
 756     do {
 757         s.added = 0;
 758         if (!EnumFontFamiliesA(hdc, NULL, FontFamilyEnumProc, (LPARAM)&s)) {
 759           TRACE("EnumFontFamilies returns 0\n");
 760           break;
 761         }
 762         if (s.added) break;
 763         if (lpcf->Flags & CF_FIXEDPITCHONLY) {
 764             FIXME("No founds found with fixed pitch only, dropping flag.\n");
 765             lpcf->Flags &= ~CF_FIXEDPITCHONLY;
 766             continue;
 767         }
 768         if (lpcf->Flags & CF_TTONLY) {
 769             FIXME("No founds found with truetype only, dropping flag.\n");
 770             lpcf->Flags &= ~CF_TTONLY;
 771             continue;
 772         }
 773         break;
 774      } while (1);
 775
 776
 777     if (lpcf->Flags & CF_INITTOLOGFONTSTRUCT)
 778     {
 779       /* look for fitting font name in combobox1 */
 780       j=SendDlgItemMessageA(hDlg,cmb1,CB_FINDSTRING,-1,(LONG)lpxx->lfFaceName);
 781       if (j!=CB_ERR)
 782       {
 783         SendDlgItemMessageA(hDlg, cmb1, CB_SETCURSEL, j, 0);
 784         SendMessageA(hDlg, WM_COMMAND, MAKEWPARAM(cmb1, CBN_SELCHANGE),
 785                        GetDlgItem(hDlg,cmb1));
 786         init=1;
 787         /* look for fitting font style in combobox2 */
 788         l=MAKELONG(lpxx->lfWeight > FW_MEDIUM ? FW_BOLD:FW_NORMAL,lpxx->lfItalic !=0);
 789         for (i=0;i<TEXT_EXTRAS;i++)
 790         {
 791           if (l==SendDlgItemMessageA(hDlg, cmb2, CB_GETITEMDATA, i, 0))
 792             SendDlgItemMessageA(hDlg, cmb2, CB_SETCURSEL, i, 0);
 793         }
 794
 795         /* look for fitting font size in combobox3 */
 796         j=SendDlgItemMessageA(hDlg, cmb3, CB_GETCOUNT, 0, 0);
 797         for (i=0;i<j;i++)
 798         {
 799           if (lpxx->lfHeight==(int)SendDlgItemMessageA(hDlg,cmb3, CB_GETITEMDATA,i,0))
 800             SendDlgItemMessageA(hDlg,cmb3,CB_SETCURSEL,i,0);
 801         }
 802       }
 803     }
 804     if (!init)
 805     {
 806       SendDlgItemMessageA(hDlg,cmb1,CB_SETCURSEL,0,0);
 807       SendMessageA(hDlg, WM_COMMAND, MAKEWPARAM(cmb1, CBN_SELCHANGE),
 808                        GetDlgItem(hDlg,cmb1));
 809     }
 810     if (lpcf->Flags & CF_USESTYLE && lpcf->lpszStyle)
 811     {
 812       j=SendDlgItemMessageA(hDlg,cmb2,CB_FINDSTRING,-1,(LONG)lpcf->lpszStyle);
 813       if (j!=CB_ERR)
 814       {
 815         j=SendDlgItemMessageA(hDlg,cmb2,CB_SETCURSEL,j,0);
 816         SendMessageA(hDlg,WM_COMMAND,cmb2,
 817                        MAKELONG(GetDlgItem(hDlg,cmb2),CBN_SELCHANGE));
 818       }
 819     }
 820   }
 821   else
 822   {
 823     WARN("HDC failure !!!\n");
 824     EndDialog (hDlg, 0);
 825     return FALSE;
 826   }
 827
 828   if (!((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC))
 829     ReleaseDC(hDlg,hdc);
 830   SetCursor(hcursor);
 831   return TRUE;
 832 }
 833
 834
 835 /***********************************************************************
 836  *           CFn_WMMeasureItem                           [internal]
 837  */
 838 static LRESULT CFn_WMMeasureItem(HWND hDlg, WPARAM wParam, LPARAM lParam)
 839 {
 840   BITMAP bm;
 841   LPMEASUREITEMSTRUCT lpmi=(LPMEASUREITEMSTRUCT)lParam;
 842   if (!hBitmapTT)
 843     hBitmapTT = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_TRTYPE));
 844   GetObjectA( hBitmapTT, sizeof(bm), &bm );
 845   lpmi->itemHeight=bm.bmHeight;
 846   /* FIXME: use MAX of bm.bmHeight and tm.tmHeight .*/
 847   return 0;
 848 }
 849
 850
 851 /***********************************************************************
 852  *           CFn_WMDrawItem                              [internal]
 853  */
 854 static LRESULT CFn_WMDrawItem(HWND hDlg, WPARAM wParam, LPARAM lParam)
 855 {
 856   HBRUSH hBrush;
 857   char buffer[40];
 858   BITMAP bm;
 859   COLORREF cr, oldText=0, oldBk=0;
 860   RECT rect;
 861 #if 0
 862   HDC hMemDC;
 863   int nFontType;
 864   HBITMAP hBitmap; /* for later TT usage */
 865 #endif
 866   LPDRAWITEMSTRUCT lpdi = (LPDRAWITEMSTRUCT)lParam;
 867
 868   if (lpdi->itemID == (UINT)-1)  /* got no items */
 869     DrawFocusRect(lpdi->hDC, &lpdi->rcItem);
 870   else
 871   {
 872    if (lpdi->CtlType == ODT_COMBOBOX)
 873    {
 874      if (lpdi->itemState ==ODS_SELECTED)
 875      {
 876        hBrush=GetSysColorBrush(COLOR_HIGHLIGHT);
 877        oldText=SetTextColor(lpdi->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 878        oldBk=SetBkColor(lpdi->hDC, GetSysColor(COLOR_HIGHLIGHT));
 879      }  else
 880      {
 881        hBrush = SelectObject(lpdi->hDC, GetStockObject(LTGRAY_BRUSH));
 882        SelectObject(lpdi->hDC, hBrush);
 883      }
 884      FillRect(lpdi->hDC, &lpdi->rcItem, hBrush);
 885    }
 886    else
 887      return TRUE;       /* this should never happen */
 888
 889    rect=lpdi->rcItem;
 890    switch (lpdi->CtlID)
 891    {
 892     case cmb1:  /* TRACE(commdlg,"WM_Drawitem cmb1\n"); */
 893                 SendMessageA(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
 894                                (LPARAM)buffer);
 895                 GetObjectA( hBitmapTT, sizeof(bm), &bm );
 896                 TextOutA(lpdi->hDC, lpdi->rcItem.left + bm.bmWidth + 10,
 897                            lpdi->rcItem.top, buffer, strlen(buffer));
 898 #if 0
 899                 nFontType = SendMessageA(lpdi->hwndItem, CB_GETITEMDATA, lpdi->itemID,0L);
 900                   /* FIXME: draw bitmap if truetype usage */
 901                 if (nFontType&TRUETYPE_FONTTYPE)
 902                 {
 903                   hMemDC = CreateCompatibleDC(lpdi->hDC);
 904                   hBitmap = SelectObject(hMemDC, hBitmapTT);
 905                   BitBlt(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top,
 906                            bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
 907                   SelectObject(hMemDC, hBitmap);
 908                   DeleteDC(hMemDC);
 909                 }
 910 #endif
 911                 break;
 912     case cmb2:
 913     case cmb3:  /* TRACE(commdlg,"WM_DRAWITEN cmb2,cmb3\n"); */
 914                 SendMessageA(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
 915                                (LPARAM)buffer);
 916                 TextOutA(lpdi->hDC, lpdi->rcItem.left,
 917                            lpdi->rcItem.top, buffer, strlen(buffer));
 918                 break;
 919
 920     case cmb4:  /* TRACE(commdlg,"WM_DRAWITEM cmb4 (=COLOR)\n"); */
 921                 SendMessageA(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
 922                                (LPARAM)buffer);
 923                 TextOutA(lpdi->hDC, lpdi->rcItem.left +  25+5,
 924                            lpdi->rcItem.top, buffer, strlen(buffer));
 925                 cr = SendMessageA(lpdi->hwndItem, CB_GETITEMDATA, lpdi->itemID,0L);
 926                 hBrush = CreateSolidBrush(cr);
 927                 if (hBrush)
 928                 {
 929                   hBrush = SelectObject (lpdi->hDC, hBrush) ;
 930                   rect.right=rect.left+25;
 931                   rect.top++;
 932                   rect.left+=5;
 933                   rect.bottom--;
 934                   Rectangle( lpdi->hDC, rect.left, rect.top,
 935                                rect.right, rect.bottom );
 936                   DeleteObject( SelectObject (lpdi->hDC, hBrush)) ;
 937                 }
 938                 rect=lpdi->rcItem;
 939                 rect.left+=25+5;
 940                 break;
 941
 942     default:    return TRUE;    /* this should never happen */
 943    }
 944    if (lpdi->itemState == ODS_SELECTED)
 945    {
 946      SetTextColor(lpdi->hDC, oldText);
 947      SetBkColor(lpdi->hDC, oldBk);
 948    }
 949  }
 950  return TRUE;
 951 }
 952
 953 /***********************************************************************
 954  *           CFn_WMCtlColor                              [internal]
 955  */
 956 static LRESULT CFn_WMCtlColorStatic(HWND hDlg, WPARAM wParam, LPARAM lParam,
 957                              LPCHOOSEFONTA lpcf)
 958 {
 959   if (lpcf->Flags & CF_EFFECTS)
 960    if (GetDlgCtrlID(lParam)==stc6)
 961    {
 962      SetTextColor((HDC)wParam, lpcf->rgbColors);
 963      return GetStockObject(WHITE_BRUSH);
 964    }
 965   return 0;
 966 }
 967
 968 /***********************************************************************
 969  *           CFn_WMCommand                               [internal]
 970  */
 971 static LRESULT CFn_WMCommand(HWND hDlg, WPARAM wParam, LPARAM lParam,
 972                       LPCHOOSEFONTA lpcf)
 973 {
 974   HFONT hFont;
 975   int i,j;
 976   long l;
 977   HDC hdc;
 978   LPLOGFONTA lpxx=lpcf->lpLogFont;
 979
 980   TRACE("WM_COMMAND wParam=%08lX lParam=%08lX\n", (LONG)wParam, lParam);
 981   switch (LOWORD(wParam))
 982   {
 983         case cmb1:if (HIWORD(wParam)==CBN_SELCHANGE)
 984                   {
 985                     hdc=((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC) ? lpcf->hDC : GetDC(hDlg);
 986                     if (hdc)
 987                     {
 988                       SendDlgItemMessageA(hDlg, cmb2, CB_RESETCONTENT16, 0, 0);
 989                       SendDlgItemMessageA(hDlg, cmb3, CB_RESETCONTENT16, 0, 0);
 990                       i=SendDlgItemMessageA(hDlg, cmb1, CB_GETCURSEL16, 0, 0);
 991                       if (i!=CB_ERR)
 992                       {
 993                         HCURSOR hcursor=SetCursor(LoadCursorA(0,IDC_WAITA));
 994                         CFn_ENUMSTRUCT s;
 995                         char str[256];
 996                         SendDlgItemMessageA(hDlg, cmb1, CB_GETLBTEXT, i,
 997                                               (LPARAM)str);
 998                         TRACE("WM_COMMAND/cmb1 =>%s\n",str);
 999                         s.hWnd1=GetDlgItem(hDlg, cmb2);
1000                         s.hWnd2=GetDlgItem(hDlg, cmb3);
1001                         s.lpcf32a=lpcf;
1002                         EnumFontFamiliesA(hdc, str, FontStyleEnumProc, (LPARAM)&s);
1003                         SendDlgItemMessageA(hDlg,cmb2, CB_SETCURSEL, 0, 0);
1004                         SendDlgItemMessageA(hDlg,cmb3, CB_SETCURSEL, 0, 0);
1005                         SetCursor(hcursor);
1006                       }
1007                       if (!((lpcf->Flags & CF_PRINTERFONTS) && lpcf->hDC))
1008                         ReleaseDC(hDlg,hdc);
1009                     }
1010                     else
1011                     {
1012                       WARN("HDC failure !!!\n");
1013                       EndDialog (hDlg, 0);
1014                       return TRUE;
1015                     }
1016                   }
1017         case chx1:
1018         case chx2:
1019         case cmb2:
1020         case cmb3:if (HIWORD(wParam)==CBN_SELCHANGE || HIWORD(wParam)== BN_CLICKED )
1021                   {
1022                     char str[256];
1023                     TRACE("WM_COMMAND/cmb2,3 =%08lX\n", lParam);
1024                     i=SendDlgItemMessageA(hDlg,cmb1,CB_GETCURSEL,0,0);
1025                     if (i==CB_ERR)
1026                       i=GetDlgItemTextA( hDlg, cmb1, str, 256 );
1027                     else
1028                     {
1029                       SendDlgItemMessageA(hDlg,cmb1,CB_GETLBTEXT,i,
1030                                             (LPARAM)str);
1031                       l=SendDlgItemMessageA(hDlg,cmb1,CB_GETITEMDATA,i,0);
1032                       j=HIWORD(l);
1033                       lpcf->nFontType = LOWORD(l);
1034                       /* FIXME:   lpcf->nFontType |= ....  SIMULATED_FONTTYPE and so */
1035                       /* same value reported to the EnumFonts
1036                        call back with the extra FONTTYPE_...  bits added */
1037                       lpxx->lfPitchAndFamily=j&0xff;
1038                       lpxx->lfCharSet=j>>8;
1039                     }
1040                     strcpy(lpxx->lfFaceName,str);
1041                     i=SendDlgItemMessageA(hDlg, cmb2, CB_GETCURSEL, 0, 0);
1042                     if (i!=CB_ERR)
1043                     {
1044                       l=SendDlgItemMessageA(hDlg, cmb2, CB_GETITEMDATA, i, 0);
1045                       if (0!=(lpxx->lfItalic=HIWORD(l)))
1046                         lpcf->nFontType |= ITALIC_FONTTYPE;
1047                       if ((lpxx->lfWeight=LOWORD(l)) > FW_MEDIUM)
1048                         lpcf->nFontType |= BOLD_FONTTYPE;
1049                     }
1050                     i=SendDlgItemMessageA(hDlg, cmb3, CB_GETCURSEL, 0, 0);
1051                     if (i!=CB_ERR)
1052                       lpxx->lfHeight=-LOWORD(SendDlgItemMessageA(hDlg, cmb3, CB_GETITEMDATA, i, 0));
1053                     else
1054                       lpxx->lfHeight=0;
1055                     lpxx->lfStrikeOut=IsDlgButtonChecked(hDlg,chx1);
1056                     lpxx->lfUnderline=IsDlgButtonChecked(hDlg,chx2);
1057                     lpxx->lfWidth=lpxx->lfOrientation=lpxx->lfEscapement=0;
1058                     lpxx->lfOutPrecision=OUT_DEFAULT_PRECIS;
1059                     lpxx->lfClipPrecision=CLIP_DEFAULT_PRECIS;
1060                     lpxx->lfQuality=DEFAULT_QUALITY;
1061                     lpcf->iPointSize= -10*lpxx->lfHeight;
1062
1063                     hFont=CreateFontIndirectA(lpxx);
1064                     if (hFont)
1065                     {
1066                       HFONT oldFont=SendDlgItemMessageA(hDlg, stc6,
1067                           WM_GETFONT, 0, 0);
1068                       SendDlgItemMessageA(hDlg,stc6,WM_SETFONT,hFont,TRUE);
1069                       DeleteObject(oldFont);
1070                     }
1071                   }
1072                   break;
1073
1074         case cmb4:i=SendDlgItemMessageA(hDlg, cmb4, CB_GETCURSEL, 0, 0);
1075                   if (i!=CB_ERR)
1076                   {
1077                    lpcf->rgbColors=textcolors[i];
1078                    InvalidateRect( GetDlgItem(hDlg,stc6), NULL, 0 );
1079                   }
1080                   break;
1081
1082         case psh15:i=RegisterWindowMessageA( HELPMSGSTRINGA );
1083                   if (lpcf->hwndOwner)
1084                     SendMessageA(lpcf->hwndOwner, i, 0, (LPARAM)GetWindowLongA(hDlg, DWL_USER));
1085 /*                if (CFn_HookCallChk(lpcf))
1086                     CallWindowProc16(lpcf->lpfnHook,hDlg,WM_COMMAND,psh15,(LPARAM)lpcf);*/
1087                   break;
1088
1089         case IDOK:if (  (!(lpcf->Flags & CF_LIMITSIZE))  ||
1090                      ( (lpcf->Flags & CF_LIMITSIZE) &&
1091                       (-lpxx->lfHeight >= lpcf->nSizeMin) &&
1092                       (-lpxx->lfHeight <= lpcf->nSizeMax)))
1093                      EndDialog(hDlg, TRUE);
1094                   else
1095                   {
1096                    char buffer[80];
1097                    sprintf(buffer,"Select a font size between %d and %d points.",
1098                            lpcf->nSizeMin,lpcf->nSizeMax);
1099                    MessageBoxA(hDlg, buffer, NULL, MB_OK);
1100                   }
1101                   return(TRUE);
1102         case IDCANCEL:EndDialog(hDlg, FALSE);
1103                   return(TRUE);
1104         }
1105       return(FALSE);
1106 }
1107
1108 static LRESULT CFn_WMDestroy(HWND hwnd, WPARAM wParam, LPARAM lParam)
1109 {
1110   DeleteObject(SendDlgItemMessageA(hwnd, stc6, WM_GETFONT, 0, 0));
1111   return TRUE;
1112 }
1113
1114
1115 /***********************************************************************
1116  *           FormatCharDlgProc   (COMMDLG.16)
1117              FIXME: 1. some strings are "hardcoded", but it's better load from sysres
1118                     2. some CF_.. flags are not supported
1119                     3. some TType extensions
1120  */
1121 LRESULT WINAPI FormatCharDlgProc16(HWND16 hDlg, UINT16 message, WPARAM16 wParam,
1122                                    LPARAM lParam)
1123 {
1124   LPCHOOSEFONT16 lpcf;
1125   LPCHOOSEFONTA lpcf32a;
1126   LRESULT res=0;
1127   if (message!=WM_INITDIALOG)
1128   {
1129    lpcf=(LPCHOOSEFONT16)GetWindowLongA(hDlg, DWL_USER);
1130    if (!lpcf)
1131       return FALSE;
1132    if (CFn_HookCallChk(lpcf))
1133      res=CallWindowProc16((WNDPROC16)lpcf->lpfnHook,hDlg,message,wParam,lParam);
1134    if (res)
1135     return res;
1136   }
1137   else
1138   {
1139     lpcf=(LPCHOOSEFONT16)lParam;
1140     lpcf32a=(LPCHOOSEFONTA)lpcf->lpTemplateName;
1141     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf32a))
1142     {
1143       TRACE("CFn_WMInitDialog returned FALSE\n");
1144       return FALSE;
1145     }
1146     if (CFn_HookCallChk(lpcf))
1147       return CallWindowProc16((WNDPROC16)lpcf->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
1148   }
1149   lpcf32a=(LPCHOOSEFONTA)lpcf->lpTemplateName;
1150   switch (message)
1151     {
1152     case WM_MEASUREITEM:
1153         {
1154             MEASUREITEMSTRUCT16* mis16 = MapSL(lParam);
1155             MEASUREITEMSTRUCT mis;
1156             mis.CtlType    = mis16->CtlType;
1157             mis.CtlID      = mis16->CtlID;
1158             mis.itemID     = mis16->itemID;
1159             mis.itemWidth  = mis16->itemWidth;
1160             mis.itemHeight = mis16->itemHeight;
1161             mis.itemData   = mis16->itemData;
1162             res = CFn_WMMeasureItem(hDlg, wParam, (LPARAM)&mis);
1163             mis16->itemWidth  = (UINT16)mis.itemWidth;
1164             mis16->itemHeight = (UINT16)mis.itemHeight;
1165         }
1166         break;
1167     case WM_DRAWITEM:
1168         {
1169             DRAWITEMSTRUCT16* dis16 = MapSL(lParam);
1170             DRAWITEMSTRUCT dis;
1171             dis.CtlType    = dis16->CtlType;
1172             dis.CtlID      = dis16->CtlID;
1173             dis.itemID     = dis16->itemID;
1174             dis.itemAction = dis16->itemAction;
1175             dis.itemState  = dis16->itemState;
1176             dis.hwndItem   = dis16->hwndItem;
1177             dis.hDC        = dis16->hDC;
1178             dis.itemData   = dis16->itemData;
1179             CONV_RECT16TO32( &dis16->rcItem, &dis.rcItem );
1180             res = CFn_WMDrawItem(hDlg, wParam, (LPARAM)&dis);
1181         }
1182         break;
1183     case WM_CTLCOLOR:
1184         if (HIWORD(lParam) == CTLCOLOR_STATIC)
1185             res=CFn_WMCtlColorStatic(hDlg, (HDC)wParam, (HWND)LOWORD(lParam), lpcf32a);
1186         break;
1187     case WM_COMMAND:
1188         res=CFn_WMCommand(hDlg, MAKEWPARAM( wParam, HIWORD(lParam) ), LOWORD(lParam), lpcf32a);
1189         break;
1190     case WM_DESTROY:
1191         res=CFn_WMDestroy(hDlg, wParam, lParam);
1192         break;
1193     case WM_CHOOSEFONT_GETLOGFONT:
1194         TRACE("WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n", lParam);
1195         FIXME("current logfont back to caller\n");
1196         break;
1197     }
1198   return res;
1199 }
1200
1201 /***********************************************************************
1202  *           FormatCharDlgProcA   [internal]
1203  */
1204 LRESULT WINAPI FormatCharDlgProcA(HWND hDlg, UINT uMsg, WPARAM wParam,
1205                                     LPARAM lParam)
1206 {
1207   LPCHOOSEFONTA lpcf;
1208   LRESULT res=FALSE;
1209   if (uMsg!=WM_INITDIALOG)
1210   {
1211    lpcf=(LPCHOOSEFONTA)GetWindowLongA(hDlg, DWL_USER);
1212    if (!lpcf)
1213      return FALSE;
1214    if (CFn_HookCallChk32(lpcf))
1215      res=CallWindowProcA((WNDPROC)lpcf->lpfnHook, hDlg, uMsg, wParam, lParam);
1216    if (res)
1217      return res;
1218   }
1219   else
1220   {
1221     lpcf=(LPCHOOSEFONTA)lParam;
1222     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf))
1223     {
1224       TRACE("CFn_WMInitDialog returned FALSE\n");
1225       return FALSE;
1226     }
1227     if (CFn_HookCallChk32(lpcf))
1228       return CallWindowProcA((WNDPROC)lpcf->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
1229   }
1230   switch (uMsg)
1231     {
1232       case WM_MEASUREITEM:
1233                         return CFn_WMMeasureItem(hDlg, wParam, lParam);
1234       case WM_DRAWITEM:
1235                         return CFn_WMDrawItem(hDlg, wParam, lParam);
1236       case WM_CTLCOLORSTATIC:
1237                         return CFn_WMCtlColorStatic(hDlg, wParam, lParam, lpcf);
1238       case WM_COMMAND:
1239                         return CFn_WMCommand(hDlg, wParam, lParam, lpcf);
1240       case WM_DESTROY:
1241                         return CFn_WMDestroy(hDlg, wParam, lParam);
1242       case WM_CHOOSEFONT_GETLOGFONT:
1243                          TRACE("WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n",
1244                                       lParam);
1245                          FIXME("current logfont back to caller\n");
1246                         break;
1247     }
1248   return res;
1249 }
1250
1251 /***********************************************************************
1252  *           FormatCharDlgProcW   [internal]
1253  */
1254 LRESULT WINAPI FormatCharDlgProcW(HWND hDlg, UINT uMsg, WPARAM wParam,
1255                                     LPARAM lParam)
1256 {
1257   LPCHOOSEFONTW lpcf32w;
1258   LPCHOOSEFONTA lpcf32a;
1259   LRESULT res=FALSE;
1260   if (uMsg!=WM_INITDIALOG)
1261   {
1262    lpcf32w=(LPCHOOSEFONTW)GetWindowLongA(hDlg, DWL_USER);
1263    if (!lpcf32w)
1264      return FALSE;
1265    if (CFn_HookCallChk32((LPCHOOSEFONTA)lpcf32w))
1266      res=CallWindowProcW((WNDPROC)lpcf32w->lpfnHook, hDlg, uMsg, wParam, lParam);
1267    if (res)
1268      return res;
1269   }
1270   else
1271   {
1272     lpcf32w=(LPCHOOSEFONTW)lParam;
1273     lpcf32a=(LPCHOOSEFONTA)lpcf32w->lpTemplateName;
1274     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf32a))
1275     {
1276       TRACE("CFn_WMInitDialog returned FALSE\n");
1277       return FALSE;
1278     }
1279     if (CFn_HookCallChk32((LPCHOOSEFONTA)lpcf32w))
1280       return CallWindowProcW((WNDPROC)lpcf32w->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
1281   }
1282   lpcf32a=(LPCHOOSEFONTA)lpcf32w->lpTemplateName;
1283   switch (uMsg)
1284     {
1285       case WM_MEASUREITEM:
1286                         return CFn_WMMeasureItem(hDlg, wParam, lParam);
1287       case WM_DRAWITEM:
1288                         return CFn_WMDrawItem(hDlg, wParam, lParam);
1289       case WM_CTLCOLORSTATIC:
1290                         return CFn_WMCtlColorStatic(hDlg, wParam, lParam, lpcf32a);
1291       case WM_COMMAND:
1292                         return CFn_WMCommand(hDlg, wParam, lParam, lpcf32a);
1293       case WM_DESTROY:
1294                         return CFn_WMDestroy(hDlg, wParam, lParam);
1295       case WM_CHOOSEFONT_GETLOGFONT:
1296                          TRACE("WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n",
1297                                       lParam);
1298                          FIXME("current logfont back to caller\n");
1299                         break;
1300     }
1301   return res;
1302 }
1303
1304