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