?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 941122
[wine/multimedia.git] / objects / font.c
blobf051b8a134055c89aeaefafe076c3338f6ff8c52
1 /*
2 * GDI font objects
3 *
4 * Copyright 1993 Alexandre Julliard
5 */
6
7 static char Copyright[] = "Copyright Alexandre Julliard, 1993";
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <X11/Xatom.h>
13 #include "user.h"
14 #include "gdi.h"
15 #include "stddebug.h"
16 /* #define DEBUG_FONT */
17 /* #undef DEBUG_FONT */
18 #include "debug.h"
19
20 #define MAX_FONTS 256
21 static LPLOGFONT lpLogFontList[MAX_FONTS] = { NULL };
22
23
24 #define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
25 (((cs)->rbearing|(cs)->lbearing| \
26 (cs)->ascent|(cs)->descent) == 0))
27
28 /*
29 * CI_GET_CHAR_INFO - return the charinfo struct for the indicated 8bit
30 * character. If the character is in the column and exists, then return the
31 * appropriate metrics (note that fonts with common per-character metrics will
32 * return min_bounds). If none of these hold true, try again with the default
33 * char.
34 */
35 #define CI_GET_CHAR_INFO(fs,col,def,cs) \
36 { \
37 cs = def; \
38 if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
39 if (fs->per_char == NULL) { \
40 cs = &fs->min_bounds; \
41 } else { \
42 cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
43 if (CI_NONEXISTCHAR(cs)) cs = def; \
44 } \
45 } \
46 }
47
48 #define CI_GET_DEFAULT_INFO(fs,cs) \
49 CI_GET_CHAR_INFO(fs, fs->default_char, NULL, cs)
50
51 struct FontStructure {
52 char *window;
53 char *x11;
54 } FontNames[32];
55 int FontSize;
56
57 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
58 * Font_Init
59 */
60
61 void Font_Init( void )
62 {
63 char temp[1024];
64 LPSTR ptr;
65 int i;
66
67 if( GetPrivateProfileString("fonts", NULL, "*", temp, sizeof(temp), WINE_INI) > 2 ) {
68 for( ptr = temp, i = 1; strlen(ptr) != 0; ptr += strlen(ptr) + 1 )
69 if( strcmp( ptr, "default" ) )
70 FontNames[i++].window = strdup( ptr );
71 FontSize = i;
72
73 for( i = 1; i < FontSize; i++ ) {
74 GetPrivateProfileString("fonts", FontNames[i].window, "*", temp, sizeof(temp), WINE_INI);
75 FontNames[i].x11 = strdup( temp );
76 }
77 GetPrivateProfileString("fonts", "default", "*", temp, sizeof(temp), WINE_INI);
78 FontNames[0].x11 = strdup( temp );
79
80 } else {
81 FontNames[0].window = NULL; FontNames[0].x11 = "bitstream-courier";
82 FontNames[1].window = "ms sans serif"; FontNames[1].x11 = "*-helvetica";
83 FontNames[2].window = "ms serif"; FontNames[2].x11 = "*-times";
84 FontNames[3].window = "fixedsys"; FontNames[3].x11 = "*-fixed";
85 FontNames[4].window = "arial"; FontNames[4].x11 = "*-helvetica";
86 FontNames[5].window = "helv"; FontNames[5].x11 = "*-helvetica";
87 FontNames[6].window = "roman"; FontNames[6].x11 = "*-times";
88 FontSize = 7;
89 }
90 }
91
92 /***********************************************************************
93 * FONT_TranslateName
94 *
95 * Translate a Windows face name to its X11 equivalent.
96 * This will probably have to be customizable.
97 */
98 static const char *FONT_TranslateName( char *winFaceName )
99 {
100 int i;
101
102 for (i = 1; i < FontSize; i ++)
103 if( !strcmp( winFaceName, FontNames[i].window ) ) {
104 dprintf_font(stddeb, "---- Mapped %s to %s\n", winFaceName, FontNames[i].x11 );
105 return FontNames[i].x11;
106 }
107 return FontNames[0].x11;
108 }
109
110
111 /***********************************************************************
112 * FONT_MatchFont
113 *
114 * Find a X font matching the logical font.
115 */
116 static XFontStruct * FONT_MatchFont( LOGFONT * font, DC * dc )
117 {
118 char pattern[100];
119 const char *family, *weight, *charset;
120 char **names;
121 char slant, spacing;
122 int width, height, count;
123 XFontStruct * fontStruct;
124
125 weight = (font->lfWeight > 550) ? "bold" : "medium";
126 slant = font->lfItalic ? 'i' : 'r';
127 height = font->lfHeight * dc->w.VportExtX / dc->w.WndExtX;
128 if (height == 0) height = 120; /* Default height = 12 */
129 else if (height < 0)
130 {
131 /* If height is negative, it means the height of the characters */
132 /* *without* the internal leading. So we adjust it a bit to */
133 /* compensate. 5/4 seems to give good results for small fonts. */
134 height = 10 * (-height * 5 / 4);
135 }
136 else height *= 10;
137 width = 10 * (font->lfWidth * dc->w.VportExtY / dc->w.WndExtY);
138 spacing = (font->lfPitchAndFamily & FIXED_PITCH) ? 'm' :
139 (font->lfPitchAndFamily & VARIABLE_PITCH) ? 'p' : '*';
140 charset = (font->lfCharSet == ANSI_CHARSET) ? "iso8859-1" : "*-*";
141 if (*font->lfFaceName) family = FONT_TranslateName( font->lfFaceName );
142 else switch(font->lfPitchAndFamily & 0xf0)
143 {
144 case FF_ROMAN:
145 family = FONT_TranslateName( "roman" );
146 break;
147 case FF_SWISS:
148 family = FONT_TranslateName( "swiss" );
149 break;
150 case FF_MODERN:
151 family = FONT_TranslateName( "modern" );
152 break;
153 case FF_SCRIPT:
154 family = FONT_TranslateName( "script" );
155 break;
156 case FF_DECORATIVE:
157 family = FONT_TranslateName( "decorative" );
158 break;
159 default:
160 family = "*-*";
161 break;
162 }
163
164 while (TRUE) {
165 /* Width==0 seems not to be a valid wildcard on SGI's, using * instead */
166 if ( width == 0 )
167 sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-*-%s",
168 family, weight, slant, height, spacing, charset);
169 else
170 sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-%d-%s",
171 family, weight, slant, height, spacing, width, charset);
172 dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
173 names = XListFonts( display, pattern, 1, &count );
174 if (count > 0) break;
175 height -= 10;
176 if (height < 10) {
177 dprintf_font(stddeb,"*** No match for %s\n", pattern );
178 return NULL;
179 }
180 }
181 dprintf_font(stddeb," Found '%s'\n", *names );
182 fontStruct = XLoadQueryFont( display, *names );
183 XFreeFontNames( names );
184 return fontStruct;
185 }
186
187
188 /***********************************************************************
189 * FONT_GetMetrics
190 */
191 void FONT_GetMetrics( LOGFONT * logfont, XFontStruct * xfont,
192 TEXTMETRIC * metrics )
193 {
194 int average, i, count;
195 unsigned long prop;
196
197 metrics->tmAscent = xfont->ascent;
198 metrics->tmDescent = xfont->descent;
199 metrics->tmHeight = xfont->ascent + xfont->descent;
200
201 metrics->tmInternalLeading = 0;
202 if (XGetFontProperty( xfont, XA_X_HEIGHT, &prop ))
203 metrics->tmInternalLeading = xfont->ascent - (short)prop;
204 metrics->tmExternalLeading = 0;
205 metrics->tmMaxCharWidth = xfont->max_bounds.width;
206 metrics->tmWeight = logfont->lfWeight;
207 metrics->tmItalic = logfont->lfItalic;
208 metrics->tmUnderlined = logfont->lfUnderline;
209 metrics->tmStruckOut = logfont->lfStrikeOut;
210 metrics->tmFirstChar = xfont->min_char_or_byte2;
211 metrics->tmLastChar = xfont->max_char_or_byte2;
212 metrics->tmDefaultChar = xfont->default_char;
213 metrics->tmBreakChar = ' ';
214 metrics->tmPitchAndFamily = logfont->lfPitchAndFamily;
215 metrics->tmCharSet = logfont->lfCharSet;
216 metrics->tmOverhang = 0;
217 metrics->tmDigitizedAspectX = 1;
218 metrics->tmDigitizedAspectY = 1;
219
220 if (!xfont->per_char) average = metrics->tmMaxCharWidth;
221 else
222 {
223 XCharStruct * charPtr = xfont->per_char;
224 average = count = 0;
225 for (i = metrics->tmFirstChar; i <= metrics->tmLastChar; i++)
226 {
227 if (!CI_NONEXISTCHAR( charPtr ))
228 {
229 average += charPtr->width;
230 count++;
231 }
232 charPtr++;
233 }
234 if (count) average = (average + count/2) / count;
235 }
236 metrics->tmAveCharWidth = average;
237 }
238
239
240 /***********************************************************************
241 * CreateFontIndirect (GDI.57)
242 */
243 HFONT CreateFontIndirect( LOGFONT * font )
244 {
245 FONTOBJ * fontPtr;
246 HFONT hfont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
247 if (!hfont) return 0;
248 fontPtr = (FONTOBJ *) GDI_HEAP_ADDR( hfont );
249 memcpy( &fontPtr->logfont, font, sizeof(LOGFONT) );
250 AnsiLower( fontPtr->logfont.lfFaceName );
251 dprintf_font(stddeb,"CreateFontIndirect(%p); return %04x\n",font,hfont);
252 return hfont;
253 }
254
255
256 /***********************************************************************
257 * CreateFont (GDI.56)
258 */
259 HFONT CreateFont( int height, int width, int esc, int orient, int weight,
260 BYTE italic, BYTE underline, BYTE strikeout, BYTE charset,
261 BYTE outpres, BYTE clippres, BYTE quality, BYTE pitch,
262 LPSTR name )
263 {
264 LOGFONT logfont = { height, width, esc, orient, weight, italic, underline,
265 strikeout, charset, outpres, clippres, quality, pitch, };
266 strncpy( logfont.lfFaceName, name, LF_FACESIZE );
267 return CreateFontIndirect( &logfont );
268 }
269
270
271 /***********************************************************************
272 * FONT_GetObject
273 */
274 int FONT_GetObject( FONTOBJ * font, int count, LPSTR buffer )
275 {
276 if (count > sizeof(LOGFONT)) count = sizeof(LOGFONT);
277 memcpy( buffer, &font->logfont, count );
278 return count;
279 }
280
281
282 /***********************************************************************
283 * FONT_SelectObject
284 */
285 HFONT FONT_SelectObject( DC * dc, HFONT hfont, FONTOBJ * font )
286 {
287 static X_PHYSFONT stockFonts[LAST_STOCK_FONT-FIRST_STOCK_FONT+1];
288 X_PHYSFONT * stockPtr;
289 HFONT prevHandle = dc->w.hFont;
290 XFontStruct * fontStruct;
291 dprintf_font(stddeb,"FONT_SelectObject(%p, %04x, %p)\n",
292 dc, hfont, font);
293 /* Load font if necessary */
294
295 if (!font)
296 {
297 HFONT hnewfont;
298
299 hnewfont = CreateFont(10, 7, 0, 0, FW_DONTCARE,
300 FALSE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
301 DEFAULT_QUALITY, FF_DONTCARE, "*" );
302 font = (FONTOBJ *) GDI_HEAP_ADDR( hnewfont );
303 }
304
305 if (dc->header.wMagic == METAFILE_DC_MAGIC)
306 return MF_CreateFontIndirect(dc, hfont, &(font->logfont));
307
308 if ((hfont >= FIRST_STOCK_FONT) && (hfont <= LAST_STOCK_FONT))
309 stockPtr = &stockFonts[hfont - FIRST_STOCK_FONT];
310 else
311 stockPtr = NULL;
312
313 if (!stockPtr || !stockPtr->fstruct)
314 {
315 fontStruct = FONT_MatchFont( &font->logfont, dc );
316 }
317 else
318 {
319 fontStruct = stockPtr->fstruct;
320 dprintf_font(stddeb,
321 "FONT_SelectObject: Loaded font from cache %x %p\n",
322 hfont, fontStruct );
323 }
324 if (!fontStruct) return 0;
325
326 /* Free previous font */
327
328 if ((prevHandle < FIRST_STOCK_FONT) || (prevHandle > LAST_STOCK_FONT))
329 {
330 if (dc->u.x.font.fstruct)
331 XFreeFont( display, dc->u.x.font.fstruct );
332 }
333
334 /* Store font */
335
336 dc->w.hFont = hfont;
337 if (stockPtr)
338 {
339 if (!stockPtr->fstruct)
340 {
341 stockPtr->fstruct = fontStruct;
342 FONT_GetMetrics( &font->logfont, fontStruct, &stockPtr->metrics );
343 }
344 memcpy( &dc->u.x.font, stockPtr, sizeof(*stockPtr) );
345 }
346 else
347 {
348 dc->u.x.font.fstruct = fontStruct;
349 FONT_GetMetrics( &font->logfont, fontStruct, &dc->u.x.font.metrics );
350 }
351 return prevHandle;
352 }
353
354
355 /***********************************************************************
356 * GetTextCharacterExtra (GDI.89)
357 */
358 short GetTextCharacterExtra( HDC hdc )
359 {
360 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
361 if (!dc) return 0;
362 return abs( (dc->w.charExtra * dc->w.WndExtX + dc->w.VportExtX / 2)
363 / dc->w.VportExtX );
364 }
365
366
367 /***********************************************************************
368 * SetTextCharacterExtra (GDI.8)
369 */
370 short SetTextCharacterExtra( HDC hdc, short extra )
371 {
372 short prev;
373 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
374 if (!dc) return 0;
375 extra = (extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX;
376 prev = dc->w.charExtra;
377 dc->w.charExtra = abs(extra);
378 return (prev * dc->w.WndExtX + dc->w.VportExtX / 2) / dc->w.VportExtX;
379 }
380
381
382 /***********************************************************************
383 * SetTextJustification (GDI.10)
384 */
385 short SetTextJustification( HDC hdc, short extra, short breaks )
386 {
387 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
388 if (!dc) return 0;
389
390 extra = abs((extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX);
391 if (!extra) breaks = 0;
392 dc->w.breakTotalExtra = extra;
393 dc->w.breakCount = breaks;
394 if (breaks)
395 {
396 dc->w.breakExtra = extra / breaks;
397 dc->w.breakRem = extra - (dc->w.breakCount * dc->w.breakExtra);
398 }
399 else
400 {
401 dc->w.breakExtra = 0;
402 dc->w.breakRem = 0;
403 }
404 return 1;
405 }
406
407
408 /***********************************************************************
409 * GetTextFace (GDI.92)
410 */
411 INT GetTextFace( HDC hdc, INT count, LPSTR name )
412 {
413 FONTOBJ *font;
414
415 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
416 if (!dc) return 0;
417 if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
418 return 0;
419 strncpy( name, font->logfont.lfFaceName, count );
420 name[count-1] = '\0';
421 return strlen(name);
422 }
423
424
425 /***********************************************************************
426 * GetTextExtent (GDI.91)
427 */
428 DWORD GetTextExtent( HDC hdc, LPSTR str, short count )
429 {
430 SIZE size;
431 if (!GetTextExtentPoint( hdc, str, count, &size )) return 0;
432 return size.cx | (size.cy << 16);
433 }
434
435
436 /***********************************************************************
437 * GetTextExtentPoint (GDI.471)
438 */
439 BOOL GetTextExtentPoint( HDC hdc, LPSTR str, short count, LPSIZE size )
440 {
441 int dir, ascent, descent;
442 XCharStruct info;
443
444 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
445 if (!dc) return FALSE;
446 XTextExtents( dc->u.x.font.fstruct, str, count, &dir,
447 &ascent, &descent, &info );
448 size->cx = abs((info.width + dc->w.breakRem + count * dc->w.charExtra)
449 * dc->w.WndExtX / dc->w.VportExtX);
450 size->cy = abs((dc->u.x.font.fstruct->ascent+dc->u.x.font.fstruct->descent)
451 * dc->w.WndExtY / dc->w.VportExtY);
452
453 dprintf_font(stddeb,"GetTextExtentPoint(%d '%s' %d %p): returning %d,%d\n",
454 hdc, str, count, size, size->cx, size->cy );
455 return TRUE;
456 }
457
458
459 /***********************************************************************
460 * GetTextMetrics (GDI.93)
461 */
462 BOOL GetTextMetrics( HDC hdc, LPTEXTMETRIC metrics )
463 {
464 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
465 if (!dc) return FALSE;
466 memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );
467
468 metrics->tmAscent = abs( metrics->tmAscent
469 * dc->w.WndExtY / dc->w.VportExtY );
470 metrics->tmDescent = abs( metrics->tmDescent
471 * dc->w.WndExtY / dc->w.VportExtY );
472 metrics->tmHeight = metrics->tmAscent + metrics->tmDescent;
473 metrics->tmInternalLeading = abs( metrics->tmInternalLeading
474 * dc->w.WndExtY / dc->w.VportExtY );
475 metrics->tmExternalLeading = abs( metrics->tmExternalLeading
476 * dc->w.WndExtY / dc->w.VportExtY );
477 metrics->tmMaxCharWidth = abs( metrics->tmMaxCharWidth
478 * dc->w.WndExtX / dc->w.VportExtX );
479 metrics->tmAveCharWidth = abs( metrics->tmAveCharWidth
480 * dc->w.WndExtX / dc->w.VportExtX );
481 return TRUE;
482 }
483
484
485 /***********************************************************************
486 * SetMapperFlags (GDI.349)
487 */
488 DWORD SetMapperFlags(HDC hDC, DWORD dwFlag)
489 {
490 dprintf_font(stdnimp,"SetmapperFlags(%04X, %08lX) // Empty Stub !\n",
491 hDC, dwFlag);
492 return 0L;
493 }
494
495
496 /***********************************************************************/
497
498
499 /***********************************************************************
500 * GetCharWidth (GDI.350)
501 */
502 BOOL GetCharWidth(HDC hdc, WORD wFirstChar, WORD wLastChar, LPINT lpBuffer)
503 {
504 int i, j;
505 XFontStruct *xfont;
506 XCharStruct *cs, *def;
507
508 DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
509 if (!dc) return FALSE;
510 xfont = dc->u.x.font.fstruct;
511
512 /* fixed font? */
513 if (xfont->per_char == NULL)
514 {
515 for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
516 *(lpBuffer + j) = xfont->max_bounds.width;
517 return TRUE;
518 }
519
520 CI_GET_DEFAULT_INFO(xfont, def);
521
522 for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
523 {
524 CI_GET_CHAR_INFO(xfont, i, def, cs);
525 *(lpBuffer + j) = cs ? cs->width : xfont->max_bounds.width;
526 if (*(lpBuffer + j) < 0)
527 *(lpBuffer + j) = 0;
528 }
529 return TRUE;
530 }
531
532
533 /***********************************************************************
534 * AddFontResource (GDI.119)
535 */
536 int AddFontResource( LPSTR str )
537 {
538 fprintf( stdnimp, "STUB: AddFontResource('%s')\n", str );
539 return 1;
540 }
541
542
543 /***********************************************************************
544 * RemoveFontResource (GDI.136)
545 */
546 BOOL RemoveFontResource( LPSTR str )
547 {
548 fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n", str );
549 return TRUE;
550 }
551
552
553 /*************************************************************************
554 * ParseFontParms [internal]
555 */
556 int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz)
557 {
558 int i;
559 dprintf_font(stddeb,"ParseFontParms('%s', %d, %p, %d);\n",
560 lpFont, wParmsNo, lpRetStr, wMaxSiz);
561 if (lpFont == NULL) return 0;
562 if (lpRetStr == NULL) return 0;
563 for (i = 0; (*lpFont != '\0' && i != wParmsNo); ) {
564 if (*lpFont == '-') i++;
565 lpFont++;
566 }
567 if (i == wParmsNo) {
568 if (*lpFont == '-') lpFont++;
569 wMaxSiz--;
570 for (i = 0; (*lpFont != '\0' && *lpFont != '-' && i < wMaxSiz); i++)
571 *(lpRetStr + i) = *lpFont++;
572 *(lpRetStr + i) = '\0';
573 dprintf_font(stddeb,"ParseFontParms // '%s'\n", lpRetStr);
574 return i;
575 }
576 else
577 lpRetStr[0] = '\0';
578 return 0;
579 }
580
581
582 /*************************************************************************
583 * InitFontsList [internal]
584 */
585 void InitFontsList()
586 {
587 char str[32];
588 char pattern[100];
589 char *family, *weight, *charset;
590 char **names;
591 char slant, spacing;
592 int i, count;
593 LPLOGFONT lpNewFont;
594 weight = "medium";
595 slant = 'r';
596 spacing = '*';
597 charset = "*";
598 family = "*-*";
599 dprintf_font(stddeb,"InitFontsList !\n");
600 sprintf( pattern, "-%s-%s-%c-normal-*-*-*-*-*-%c-*-%s",
601 family, weight, slant, spacing, charset);
602 names = XListFonts( display, pattern, MAX_FONTS, &count );
603 dprintf_font(stddeb,"InitFontsList // count=%d \n", count);
604 for (i = 0; i < count; i++) {
605 lpNewFont = malloc(sizeof(LOGFONT) + LF_FACESIZE);
606 if (lpNewFont == NULL) {
607 dprintf_font(stddeb, "InitFontsList // Error alloc new font structure !\n");
608 break;
609 }
610 dprintf_font(stddeb,"InitFontsList // names[%d]='%s' \n", i, names[i]);
611 ParseFontParms(names[i], 2, str, sizeof(str));
612 if (strcmp(str, "fixed") == 0) strcat(str, "sys");
613 AnsiUpper(str);
614 strcpy(lpNewFont->lfFaceName, str);
615 ParseFontParms(names[i], 7, str, sizeof(str));
616 lpNewFont->lfHeight = atoi(str) / 10;
617 ParseFontParms(names[i], 12, str, sizeof(str));
618 lpNewFont->lfWidth = atoi(str) / 10;
619 lpNewFont->lfEscapement = 0;
620 lpNewFont->lfOrientation = 0;
621 lpNewFont->lfWeight = FW_REGULAR;
622 lpNewFont->lfItalic = 0;
623 lpNewFont->lfUnderline = 0;
624 lpNewFont->lfStrikeOut = 0;
625 ParseFontParms(names[i], 13, str, sizeof(str));
626 if (strcmp(str, "iso8859") == 0)
627 lpNewFont->lfCharSet = ANSI_CHARSET;
628 else
629 lpNewFont->lfCharSet = OEM_CHARSET;
630 lpNewFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
631 lpNewFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
632 lpNewFont->lfQuality = DEFAULT_QUALITY;
633 ParseFontParms(names[i], 11, str, sizeof(str));
634 switch(str[0]) {
635 case 'p':
636 lpNewFont->lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS;
637 break;
638 case 'm':
639 lpNewFont->lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
640 break;
641 default:
642 lpNewFont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
643 break;
644 }
645 dprintf_font(stddeb,"InitFontsList // lpNewFont->lfHeight=%d \n", lpNewFont->lfHeight);
646 dprintf_font(stddeb,"InitFontsList // lpNewFont->lfWidth=%d \n", lpNewFont->lfWidth);
647 dprintf_font(stddeb,"InitFontsList // lfFaceName='%s' \n", lpNewFont->lfFaceName);
648 lpLogFontList[i] = lpNewFont;
649 lpLogFontList[i+1] = NULL;
650 }
651 XFreeFontNames(names);
652 }
653
654
655 /*************************************************************************
656 * EnumFonts [GDI.70]
657 */
658 int EnumFonts(HDC hDC, LPSTR lpFaceName, FARPROC lpEnumFunc, LPSTR lpData)
659 {
660 HANDLE hLog;
661 HANDLE hMet;
662 HFONT hFont;
663 HFONT hOldFont;
664 LPLOGFONT lpLogFont;
665 LPTEXTMETRIC lptm;
666 LPSTR lpFaceList[MAX_FONTS];
667 char FaceName[LF_FACESIZE];
668 int nRet;
669 int j, i = 0;
670
671 dprintf_font(stddeb,"EnumFonts(%04X, %08X='%s', %08X, %08X)\n",
672 hDC, lpFaceName, lpFaceName, lpEnumFunc, lpData);
673 if (lpEnumFunc == NULL) return 0;
674 hLog = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LOGFONT) + LF_FACESIZE);
675 lpLogFont = (LPLOGFONT) USER_HEAP_ADDR(hLog);
676 if (lpLogFont == NULL) {
677 dprintf_font(stddeb,"EnumFonts // can't alloc LOGFONT struct !\n");
678 return 0;
679 }
680 hMet = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(TEXTMETRIC));
681 lptm = (LPTEXTMETRIC) USER_HEAP_ADDR(hMet);
682 if (lptm == NULL) {
683 USER_HEAP_FREE(hLog);
684 dprintf_font(stddeb, "EnumFonts // can't alloc TEXTMETRIC struct !\n");
685 return 0;
686 }
687 if (lpFaceName != NULL) {
688 strcpy(FaceName, lpFaceName);
689 AnsiUpper(FaceName);
690 }
691 if (lpLogFontList[0] == NULL) InitFontsList();
692 memset(lpFaceList, 0, MAX_FONTS * sizeof(LPSTR));
693 while (TRUE) {
694 if (lpLogFontList[i] == NULL) break;
695 if (lpFaceName == NULL) {
696 for (j = 0; j < MAX_FONTS; j++) {
697 if (lpFaceList[j] == NULL) break;
698 if (strcmp(lpFaceList[j], lpLogFontList[i]->lfFaceName) == 0) {
699 i++; j = 0;
700 if (lpLogFontList[i] == NULL) break;
701 }
702 }
703 if (lpLogFontList[i] == NULL) break;
704 lpFaceList[j] = lpLogFontList[i]->lfFaceName;
705 dprintf_font(stddeb,"EnumFonts // enum all 'lpFaceName' '%s' !\n", lpFaceList[j]);
706 }
707 else {
708 while(lpLogFontList[i] != NULL) {
709 if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) == 0) break;
710 i++;
711 }
712 if (lpLogFontList[i] == NULL) break;
713 }
714 memcpy(lpLogFont, lpLogFontList[i++], sizeof(LOGFONT) + LF_FACESIZE);
715 hFont = CreateFontIndirect(lpLogFont);
716 hOldFont = SelectObject(hDC, hFont);
717 GetTextMetrics(hDC, lptm);
718 SelectObject(hDC, hOldFont);
719 DeleteObject(hFont);
720 dprintf_font(stddeb,"EnumFonts // i=%d lpLogFont=%08X lptm=%08X\n", i, lpLogFont, lptm);
721
722 #ifdef WINELIB
723 nRet = (*lpEnumFunc)(lpLogFont, lptm, 0, lpData);
724 #else
725 nRet = CallBack16(lpEnumFunc, 4, 2, (int)lpLogFont,
726 2, (int)lptm, 0, (int)0, 2, (int)lpData);
727 #endif
728 if (nRet == 0) {
729 dprintf_font(stddeb,"EnumFonts // EnumEnd requested by application !\n");
730 break;
731 }
732 }
733 USER_HEAP_FREE(hMet);
734 USER_HEAP_FREE(hLog);
735 return 0;
736 }
737
738
739 /*************************************************************************
740 * EnumFontFamilies [GDI.330]
741 */
742 int EnumFontFamilies(HDC hDC, LPSTR lpszFamily, FARPROC lpEnumFunc, LPSTR lpData)
743 {
744 HANDLE hLog;
745 HANDLE hMet;
746 HFONT hFont;
747 HFONT hOldFont;
748 LPLOGFONT lpLogFont;
749 LPTEXTMETRIC lptm;
750 LPSTR lpFaceList[MAX_FONTS];
751 char FaceName[LF_FACESIZE];
752 int nRet;
753 int j, i = 0;
754
755 dprintf_font(stddeb,"EnumFontFamilies(%04X, %08X, %08X, %08X)\n",
756 hDC, lpszFamily, lpEnumFunc, lpData);
757 if (lpEnumFunc == NULL) return 0;
758 hLog = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(LOGFONT) + LF_FACESIZE);
759 lpLogFont = (LPLOGFONT) USER_HEAP_ADDR(hLog);
760 if (lpLogFont == NULL) {
761 dprintf_font(stddeb,"EnumFontFamilies // can't alloc LOGFONT struct !\n");
762 return 0;
763 }
764 hMet = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(TEXTMETRIC));
765 lptm = (LPTEXTMETRIC) USER_HEAP_ADDR(hMet);
766 if (lptm == NULL) {
767 USER_HEAP_FREE(hLog);
768 dprintf_font(stddeb,"EnumFontFamilies // can't alloc TEXTMETRIC struct !\n");
769 return 0;
770 }
771 if (lpszFamily != NULL) {
772 strcpy(FaceName, lpszFamily);
773 AnsiUpper(FaceName);
774 }
775 if (lpLogFontList[0] == NULL) InitFontsList();
776 memset(lpFaceList, 0, MAX_FONTS * sizeof(LPSTR));
777 while (TRUE) {
778 if (lpLogFontList[i] == NULL) break;
779 if (lpszFamily == NULL) {
780 if (lpLogFontList[i] == NULL) break;
781 for (j = 0; j < MAX_FONTS; j++) {
782 if (lpFaceList[j] == NULL) break;
783 if (lpLogFontList[i] == NULL) break;
784 if (strcmp(lpFaceList[j], lpLogFontList[i]->lfFaceName) == 0) {
785 i++; j = 0;
786 }
787 }
788 if (lpLogFontList[i] == NULL) break;
789 lpFaceList[j] = lpLogFontList[i]->lfFaceName;
790 dprintf_font(stddeb,"EnumFontFamilies // enum all 'lpszFamily' '%s' !\n", lpFaceList[j]);
791 }
792 else {
793 while(lpLogFontList[i] != NULL) {
794 if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) == 0) break;
795 i++;
796 }
797 if (lpLogFontList[i] == NULL) break;
798 }
799 memcpy(lpLogFont, lpLogFontList[i++], sizeof(LOGFONT) + LF_FACESIZE);
800 hFont = CreateFontIndirect(lpLogFont);
801 hOldFont = SelectObject(hDC, hFont);
802 GetTextMetrics(hDC, lptm);
803 SelectObject(hDC, hOldFont);
804 DeleteObject(hFont);
805 dprintf_font(stddeb, "EnumFontFamilies // i=%d lpLogFont=%08X lptm=%08X\n", i, lpLogFont, lptm);
806
807 #ifdef WINELIB
808 nRet = (*lpEnumFunc)(lpLogFont, lptm, 0, lpData);
809 #else
810 nRet = CallBack16(lpEnumFunc, 4, 2, (int)lpLogFont,
811 2, (int)lptm, 0, (int)0, 2, (int)lpData);
812 #endif
813 if (nRet == 0) {
814 dprintf_font(stddeb,"EnumFontFamilies // EnumEnd requested by application !\n");
815 break;
816 }
817 }
818 USER_HEAP_FREE(hMet);
819 USER_HEAP_FREE(hLog);
820 return 0;
821 }
822
823
824
Maarten's multimedia branch