2 * X11 physical font objects
4 * Copyright 1997 Alex Korobka
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * TODO: Mapping algorithm tweaks, FO_SYNTH_... flags (ExtTextOut() will
21 * have to be changed for that), dynamic font loading (FreeType).
25 #include "wine/port.h"
35 #include <sys/types.h>
47 #include "wine/library.h"
48 #include "wine/unicode.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(font
);
53 #define X_PFONT_MAGIC (0xFADE0000)
54 #define X_FMC_MAGIC (0x0000CAFE)
56 #define MAX_FONTS 1024*16
57 #define MAX_LFD_LENGTH 256
61 #define DEF_POINT_SIZE 8 /* CreateFont(0 .. ) gets this */
62 #define DEF_SCALABLE_HEIGHT 100 /* pixels */
63 #define MIN_FONT_SIZE 2 /* Min size in pixels */
64 #define MAX_FONT_SIZE 1000 /* Max size in pixels */
66 #define REMOVE_SUBSETS 1
67 #define UNMARK_SUBSETS 0
69 #define FONTCACHE 32 /* dynamic font cache size */
71 #define FF_FAMILY (FF_MODERN | FF_SWISS | FF_ROMAN | FF_DECORATIVE | FF_SCRIPT)
73 typedef struct __fontAlias
77 struct __fontAlias
* next
;
80 static fontAlias
*aliasTable
= NULL
;
82 static const char INIFontMetrics
[] = "cachedmetrics.";
83 static const char INIFontSection
[] = "Software\\Wine\\X11 Driver\\Fonts";
84 static const char INIAliasSection
[] = "Alias";
85 static const char INIIgnoreSection
[] = "Ignore";
86 static const char INIDefault
[] = "Default";
87 static const char INIDefaultFixed
[] = "DefaultFixed";
88 static const char INIGlobalMetrics
[] = "FontMetrics";
89 static const char INIDefaultSerif
[] = "DefaultSerif";
90 static const char INIDefaultSansSerif
[] = "DefaultSansSerif";
93 /* FIXME - are there any more Latin charsets ? */
94 /* FIXME - RUSSIAN, ARABIC, GREEK, HEBREW are NOT Latin */
95 #define IS_LATIN_CHARSET(ch) \
96 ((ch)==ANSI_CHARSET ||\
98 (ch)==ISO3_CHARSET ||\
99 (ch)==ISO4_CHARSET ||\
100 (ch)==RUSSIAN_CHARSET ||\
101 (ch)==ARABIC_CHARSET ||\
102 (ch)==GREEK_CHARSET ||\
103 (ch)==HEBREW_CHARSET ||\
104 (ch)==TURKISH_CHARSET ||\
105 (ch)==ISO10_CHARSET ||\
106 (ch)==BALTIC_CHARSET ||\
107 (ch)==CELTIC_CHARSET)
109 /* suffix-charset mapping tables - must be less than 254 entries long */
111 typedef struct __sufch
114 WORD charset
; /* hibyte != 0 means *internal* charset */
119 static const SuffixCharset sufch_ansi
[] = {
120 { "0", ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
},
121 { NULL
, ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
123 static const SuffixCharset sufch_iso646
[] = {
124 { "irv", ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
},
125 { NULL
, ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
127 static const SuffixCharset sufch_iso8859
[] = {
128 { "1", ANSI_CHARSET
, 28591, X11DRV_CPTABLE_SBCS
},
129 { "2", EE_CHARSET
, 28592, X11DRV_CPTABLE_SBCS
},
130 { "3", ISO3_CHARSET
, 28593, X11DRV_CPTABLE_SBCS
},
131 { "4", ISO4_CHARSET
, 28594, X11DRV_CPTABLE_SBCS
},
132 { "5", RUSSIAN_CHARSET
, 28595, X11DRV_CPTABLE_SBCS
},
133 { "6", ARABIC_CHARSET
, 28596, X11DRV_CPTABLE_SBCS
},
134 { "7", GREEK_CHARSET
, 28597, X11DRV_CPTABLE_SBCS
},
135 { "8", HEBREW_CHARSET
, 28598, X11DRV_CPTABLE_SBCS
},
136 { "9", TURKISH_CHARSET
, 28599, X11DRV_CPTABLE_SBCS
},
137 { "10", ISO10_CHARSET
, 28600, X11DRV_CPTABLE_SBCS
},
138 { "11", THAI_CHARSET
, 874, X11DRV_CPTABLE_SBCS
}, /* FIXME */
139 { "12", SYMBOL_CHARSET
, CP_SYMBOL
, X11DRV_CPTABLE_SBCS
},
140 { "13", BALTIC_CHARSET
, 28603, X11DRV_CPTABLE_SBCS
},
141 { "14", CELTIC_CHARSET
, 28604, X11DRV_CPTABLE_SBCS
},
142 { "15", ANSI_CHARSET
, 28605, X11DRV_CPTABLE_SBCS
},
143 { "16", ISO3_CHARSET
, 28606, X11DRV_CPTABLE_SBCS
},
144 { NULL
, ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
146 static const SuffixCharset sufch_microsoft
[] = {
147 { "cp1250", EE_CHARSET
, 1250, X11DRV_CPTABLE_SBCS
},
148 { "cp1251", RUSSIAN_CHARSET
, 1251, X11DRV_CPTABLE_SBCS
},
149 { "cp1252", ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
},
150 { "cp1253", GREEK_CHARSET
, 1253, X11DRV_CPTABLE_SBCS
},
151 { "cp1254", TURKISH_CHARSET
, 1254, X11DRV_CPTABLE_SBCS
},
152 { "cp1255", HEBREW_CHARSET
, 1255, X11DRV_CPTABLE_SBCS
},
153 { "cp1256", ARABIC_CHARSET
, 1256, X11DRV_CPTABLE_SBCS
},
154 { "cp1257", BALTIC_CHARSET
, 1257, X11DRV_CPTABLE_SBCS
},
155 { "fontspecific", SYMBOL_CHARSET
, CP_SYMBOL
, X11DRV_CPTABLE_SYMBOL
},
156 { "symbol", SYMBOL_CHARSET
, CP_SYMBOL
, X11DRV_CPTABLE_SYMBOL
},
157 { NULL
, ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
159 static const SuffixCharset sufch_tcvn
[] = {
160 { "0", TCVN_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}, /* FIXME */
161 { NULL
, TCVN_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
163 static const SuffixCharset sufch_tis620
[] = {
164 { "0", THAI_CHARSET
, 874, X11DRV_CPTABLE_SBCS
}, /* FIXME */
165 { NULL
, THAI_CHARSET
, 874, X11DRV_CPTABLE_SBCS
}};
167 static const SuffixCharset sufch_viscii
[] = {
168 { "1", VISCII_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}, /* FIXME */
169 { NULL
, VISCII_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
171 static const SuffixCharset sufch_windows
[] = {
172 { "1250", EE_CHARSET
, 1250, X11DRV_CPTABLE_SBCS
},
173 { "1251", RUSSIAN_CHARSET
, 1251, X11DRV_CPTABLE_SBCS
},
174 { "1252", ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
},
175 { "1253", GREEK_CHARSET
, 1253, X11DRV_CPTABLE_SBCS
},
176 { "1254", TURKISH_CHARSET
, 1254, X11DRV_CPTABLE_SBCS
},
177 { "1255", HEBREW_CHARSET
, 1255, X11DRV_CPTABLE_SBCS
},
178 { "1256", ARABIC_CHARSET
, 1256, X11DRV_CPTABLE_SBCS
},
179 { "1257", BALTIC_CHARSET
, 1257, X11DRV_CPTABLE_SBCS
},
180 { NULL
, ANSI_CHARSET
, 1252, X11DRV_CPTABLE_SBCS
}};
182 static const SuffixCharset sufch_koi8
[] = {
183 { "r", RUSSIAN_CHARSET
, 20866, X11DRV_CPTABLE_SBCS
},
184 { "ru", RUSSIAN_CHARSET
, 21866, X11DRV_CPTABLE_SBCS
},
185 { "u", RUSSIAN_CHARSET
, 21866, X11DRV_CPTABLE_SBCS
},
186 { NULL
, RUSSIAN_CHARSET
, 20866, X11DRV_CPTABLE_SBCS
}};
188 static const SuffixCharset sufch_jisx0201
[] = {
189 { "0", X11FONT_JISX0201_CHARSET
, 932, X11DRV_CPTABLE_SBCS
},
190 { NULL
, X11FONT_JISX0201_CHARSET
, 932, X11DRV_CPTABLE_SBCS
}};
192 static const SuffixCharset sufch_jisx0208
[] = {
193 { "0", SHIFTJIS_CHARSET
, 932, X11DRV_CPTABLE_CP932
},
194 { NULL
, SHIFTJIS_CHARSET
, 932, X11DRV_CPTABLE_CP932
}};
196 static const SuffixCharset sufch_jisx0212
[] = {
197 { "0", X11FONT_JISX0212_CHARSET
, 932, X11DRV_CPTABLE_CP932
},
198 { NULL
, X11FONT_JISX0212_CHARSET
, 932, X11DRV_CPTABLE_CP932
}};
200 static const SuffixCharset sufch_ksc5601
[] = {
201 { "0", HANGEUL_CHARSET
, 949, X11DRV_CPTABLE_CP949
},
202 { NULL
, HANGEUL_CHARSET
, 949, X11DRV_CPTABLE_CP949
}};
204 static const SuffixCharset sufch_gb2312
[] = {
205 { "0", GB2312_CHARSET
, 936, X11DRV_CPTABLE_CP936
},
206 { NULL
, GB2312_CHARSET
, 936, X11DRV_CPTABLE_CP936
}};
208 static const SuffixCharset sufch_big5
[] = {
209 { "0", CHINESEBIG5_CHARSET
, 950, X11DRV_CPTABLE_CP950
},
210 { NULL
, CHINESEBIG5_CHARSET
, 950, X11DRV_CPTABLE_CP950
}};
212 static const SuffixCharset sufch_unicode
[] = {
213 { "0", DEFAULT_CHARSET
, 0, X11DRV_CPTABLE_UNICODE
},
214 { NULL
, DEFAULT_CHARSET
, 0, X11DRV_CPTABLE_UNICODE
}};
216 static const SuffixCharset sufch_iso10646
[] = {
217 { "1", DEFAULT_CHARSET
, 0, X11DRV_CPTABLE_UNICODE
},
218 { NULL
, DEFAULT_CHARSET
, 0, X11DRV_CPTABLE_UNICODE
}};
220 static const SuffixCharset sufch_dec
[] = {
221 { "dectech", SYMBOL_CHARSET
, CP_SYMBOL
, X11DRV_CPTABLE_SBCS
},
222 { NULL
, 0, 0, X11DRV_CPTABLE_SBCS
}};
224 /* Each of these must be matched explicitly */
225 static const SuffixCharset sufch_any
[] = {
226 { "fontspecific", SYMBOL_CHARSET
, CP_SYMBOL
, X11DRV_CPTABLE_SBCS
},
227 { NULL
, 0, 0, X11DRV_CPTABLE_SBCS
}};
233 const SuffixCharset
* sufch
;
234 const struct __fet
* next
;
235 } fontEncodingTemplate
;
237 /* Note: we can attach additional encoding mappings to the end
238 * of this table at runtime.
240 static const fontEncodingTemplate fETTable
[] = {
241 { "ansi", sufch_ansi
, &fETTable
[1] },
242 { "ascii", sufch_ansi
, &fETTable
[2] },
243 { "iso646.1991", sufch_iso646
, &fETTable
[3] },
244 { "iso8859", sufch_iso8859
, &fETTable
[4] },
245 { "microsoft", sufch_microsoft
, &fETTable
[5] },
246 { "tcvn", sufch_tcvn
, &fETTable
[6] },
247 { "tis620.2533", sufch_tis620
, &fETTable
[7] },
248 { "viscii1.1", sufch_viscii
, &fETTable
[8] },
249 { "windows", sufch_windows
, &fETTable
[9] },
250 { "koi8", sufch_koi8
, &fETTable
[10]},
251 { "jisx0201.1976",sufch_jisx0201
, &fETTable
[11]},
252 { "jisc6226.1978",sufch_jisx0208
, &fETTable
[12]},
253 { "jisx0208.1983",sufch_jisx0208
, &fETTable
[13]},
254 { "jisx0208.1990",sufch_jisx0208
, &fETTable
[14]},
255 { "jisx0212.1990",sufch_jisx0212
, &fETTable
[15]},
256 { "ksc5601.1987", sufch_ksc5601
, &fETTable
[16]},
257 { "gb2312.1980", sufch_gb2312
, &fETTable
[17]},
258 { "big5", sufch_big5
, &fETTable
[18]},
259 { "unicode", sufch_unicode
, &fETTable
[19]},
260 { "iso10646", sufch_iso10646
, &fETTable
[20]},
261 { "cp", sufch_windows
, &fETTable
[21]},
262 { "dec", sufch_dec
, &fETTable
[22]},
263 /* NULL prefix matches anything so put it last */
264 { NULL
, sufch_any
, NULL
},
267 /* a charset database for known facenames */
268 struct CharsetBindingInfo
270 const char* pszFaceName
;
273 static const struct CharsetBindingInfo charsetbindings
[] =
275 /* special facenames */
276 { "System", DEFAULT_CHARSET
},
277 { "FixedSys", DEFAULT_CHARSET
},
279 /* known facenames */
280 { "MS Serif", ANSI_CHARSET
},
281 { "MS Sans Serif", ANSI_CHARSET
},
282 { "Courier", ANSI_CHARSET
},
283 { "Symbol", SYMBOL_CHARSET
},
285 { "Arial", ANSI_CHARSET
},
286 { "Arial Greek", GREEK_CHARSET
},
287 { "Arial Tur", TURKISH_CHARSET
},
288 { "Arial Baltic", BALTIC_CHARSET
},
289 { "Arial CE", EASTEUROPE_CHARSET
},
290 { "Arial Cyr", RUSSIAN_CHARSET
},
291 { "Courier New", ANSI_CHARSET
},
292 { "Courier New Greek", GREEK_CHARSET
},
293 { "Courier New Tur", TURKISH_CHARSET
},
294 { "Courier New Baltic", BALTIC_CHARSET
},
295 { "Courier New CE", EASTEUROPE_CHARSET
},
296 { "Courier New Cyr", RUSSIAN_CHARSET
},
297 { "Times New Roman", ANSI_CHARSET
},
298 { "Times New Roman Greek", GREEK_CHARSET
},
299 { "Times New Roman Tur", TURKISH_CHARSET
},
300 { "Times New Roman Baltic", BALTIC_CHARSET
},
301 { "Times New Roman CE", EASTEUROPE_CHARSET
},
302 { "Times New Roman Cyr", RUSSIAN_CHARSET
},
304 { "\x82\x6c\x82\x72 \x83\x53\x83\x56\x83\x62\x83\x4e",
305 SHIFTJIS_CHARSET
}, /* MS gothic */
306 { "\x82\x6c\x82\x72 \x82\x6f\x83\x53\x83\x56\x83\x62\x83\x4e",
307 SHIFTJIS_CHARSET
}, /* MS P gothic */
308 { "\x82\x6c\x82\x72 \x96\xbe\x92\xa9",
309 SHIFTJIS_CHARSET
}, /* MS mincho */
310 { "\x82\x6c\x82\x72 \x82\x6f\x96\xbe\x92\xa9",
311 SHIFTJIS_CHARSET
}, /* MS P mincho */
312 { "GulimChe", HANGEUL_CHARSET
},
313 { "\xcb\xce\xcc\xe5", GB2312_CHARSET
}, /* SimSun */
314 { "\xba\xda\xcc\xe5", GB2312_CHARSET
}, /* SimHei */
315 { "\xb7\x73\xb2\xd3\xa9\xfa\xc5\xe9", CHINESEBIG5_CHARSET
},/*MS Mingliu*/
316 { "\xb2\xd3\xa9\xfa\xc5\xe9", CHINESEBIG5_CHARSET
},
322 static int DefResolution
= 0;
324 static CRITICAL_SECTION crtsc_fonts_X11
;
325 static CRITICAL_SECTION_DEBUG critsect_debug
=
327 0, 0, &crtsc_fonts_X11
,
328 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
329 0, 0, { (DWORD_PTR
)(__FILE__
": crtsc_fonts_X11") }
331 static CRITICAL_SECTION crtsc_fonts_X11
= { &critsect_debug
, -1, 0, 0, 0, 0 };
333 static fontResource
* fontList
= NULL
;
334 static fontObject
* fontCache
= NULL
; /* array */
335 static unsigned int fontCacheSize
= FONTCACHE
;
336 static int fontLF
= -1, fontMRU
= -1; /* last free, most recently used */
338 #define __PFONT(pFont) ( fontCache + ((UINT)(pFont) & 0x0000FFFF) )
339 #define CHECK_PFONT(pFont) ( (((UINT)(pFont) & 0xFFFF0000) == X_PFONT_MAGIC) &&\
340 (((UINT)(pFont) & 0x0000FFFF) < fontCacheSize) )
342 /***********************************************************************
343 * Helper macros from X distribution
346 #define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
347 (((cs)->rbearing|(cs)->lbearing| \
348 (cs)->ascent|(cs)->descent) == 0))
350 #define CI_GET_CHAR_INFO(fs,col,def,cs) \
353 if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
354 if (fs->per_char == NULL) { \
355 cs = &fs->min_bounds; \
357 cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
358 if (CI_NONEXISTCHAR(cs)) cs = def; \
363 #define CI_GET_DEFAULT_INFO(fs,cs) \
364 CI_GET_CHAR_INFO(fs, fs->default_char, NULL, cs)
367 /***********************************************************************
370 static inline BOOL
is_stock_font( HFONT font
)
373 for (i
= OEM_FIXED_FONT
; i
<= DEFAULT_GUI_FONT
; i
++)
375 if (i
!= DEFAULT_PALETTE
&& font
== GetStockObject(i
)) return TRUE
;
381 static void FONT_LogFontWTo16( const LOGFONTW
* font32
, LPLOGFONT16 font16
)
383 font16
->lfHeight
= font32
->lfHeight
;
384 font16
->lfWidth
= font32
->lfWidth
;
385 font16
->lfEscapement
= font32
->lfEscapement
;
386 font16
->lfOrientation
= font32
->lfOrientation
;
387 font16
->lfWeight
= font32
->lfWeight
;
388 font16
->lfItalic
= font32
->lfItalic
;
389 font16
->lfUnderline
= font32
->lfUnderline
;
390 font16
->lfStrikeOut
= font32
->lfStrikeOut
;
391 font16
->lfCharSet
= font32
->lfCharSet
;
392 font16
->lfOutPrecision
= font32
->lfOutPrecision
;
393 font16
->lfClipPrecision
= font32
->lfClipPrecision
;
394 font16
->lfQuality
= font32
->lfQuality
;
395 font16
->lfPitchAndFamily
= font32
->lfPitchAndFamily
;
396 WideCharToMultiByte( CP_ACP
, 0, font32
->lfFaceName
, -1,
397 font16
->lfFaceName
, LF_FACESIZE
, NULL
, NULL
);
398 font16
->lfFaceName
[LF_FACESIZE
-1] = 0;
402 /***********************************************************************
405 static UINT16
__lfCheckSum( const LOGFONT16
*plf
)
407 CHAR font
[LF_FACESIZE
];
412 ptr
= (const UINT16
*)plf
;
413 for (i
= 0; i
< 9; i
++) checksum
^= *ptr
++;
414 for (i
= 0; i
< LF_FACESIZE
; i
++)
416 font
[i
] = tolower(plf
->lfFaceName
[i
]);
417 if (!font
[i
] || font
[i
] == ' ') break;
419 for (ptr
= (UINT16
*)font
, i
>>= 1; i
> 0; i
-- ) checksum
^= *ptr
++;
423 static UINT16
__genericCheckSum( const void *ptr
, int size
)
425 unsigned int checksum
= 0;
428 checksum
^= (checksum
<< 3) + (checksum
>> 29) + *p
++;
430 return checksum
& 0xffff;
433 /*************************************************************************
434 * LFD parse/compose routines
436 * NB. LFD_Parse will use lpFont for its own ends, so if you want to keep it
439 * These functions also do TILDE to HYPHEN conversion
441 static BOOL
LFD_Parse(LPSTR lpFont
, LFD
*lfd
)
443 char *lpch
= lpFont
, *lfd_fld
[LFD_FIELDS
], *field_start
;
447 WARN("font '%s' doesn't begin with '%c'\n", lpFont
, HYPHEN
);
451 field_start
= ++lpch
;
452 for( i
= 0; i
< LFD_FIELDS
; )
457 lfd_fld
[i
] = field_start
;
459 field_start
= ++lpch
;
463 lfd_fld
[i
] = field_start
;
467 else if (*lpch
== TILDE
)
475 /* Fill in the empty fields with NULLS */
476 for (; i
< LFD_FIELDS
; i
++)
479 WARN("Extra ignored in font '%s'\n", lpFont
);
481 lfd
->foundry
= lfd_fld
[0];
482 lfd
->family
= lfd_fld
[1];
483 lfd
->weight
= lfd_fld
[2];
484 lfd
->slant
= lfd_fld
[3];
485 lfd
->set_width
= lfd_fld
[4];
486 lfd
->add_style
= lfd_fld
[5];
487 lfd
->pixel_size
= lfd_fld
[6];
488 lfd
->point_size
= lfd_fld
[7];
489 lfd
->resolution_x
= lfd_fld
[8];
490 lfd
->resolution_y
= lfd_fld
[9];
491 lfd
->spacing
= lfd_fld
[10];
492 lfd
->average_width
= lfd_fld
[11];
493 lfd
->charset_registry
= lfd_fld
[12];
494 lfd
->charset_encoding
= lfd_fld
[13];
499 static void LFD_UnParse(LPSTR dp
, UINT buf_size
, LFD
* lfd
)
501 const char* lfd_fld
[LFD_FIELDS
];
505 return; /* Don't be silly */
507 lfd_fld
[0] = lfd
->foundry
;
508 lfd_fld
[1] = lfd
->family
;
509 lfd_fld
[2] = lfd
->weight
;
510 lfd_fld
[3] = lfd
->slant
;
511 lfd_fld
[4] = lfd
->set_width
;
512 lfd_fld
[5] = lfd
->add_style
;
513 lfd_fld
[6] = lfd
->pixel_size
;
514 lfd_fld
[7] = lfd
->point_size
;
515 lfd_fld
[8] = lfd
->resolution_x
;
516 lfd_fld
[9] = lfd
->resolution_y
;
517 lfd_fld
[10] = lfd
->spacing
;
518 lfd_fld
[11] = lfd
->average_width
;
519 lfd_fld
[12] = lfd
->charset_registry
;
520 lfd_fld
[13] = lfd
->charset_encoding
;
522 buf_size
--; /* Room for the terminator */
524 for (i
= 0; i
< LFD_FIELDS
; i
++)
526 const char* sp
= lfd_fld
[i
];
527 if (!sp
|| !buf_size
)
532 while (buf_size
> 0 && *sp
)
534 *dp
= (*sp
== HYPHEN
) ? TILDE
: *sp
;
543 static void LFD_GetWeight( fontInfo
* fi
, LPCSTR lpStr
)
545 int j
= strlen(lpStr
);
546 if( j
== 1 && *lpStr
== '0')
547 fi
->fi_flags
|= FI_POLYWEIGHT
;
550 if( !strcasecmp( "bold", lpStr
) )
551 fi
->df
.dfWeight
= FW_BOLD
;
552 else if( !strcasecmp( "demi", lpStr
) )
554 fi
->fi_flags
|= FI_FW_DEMI
;
555 fi
->df
.dfWeight
= FW_DEMIBOLD
;
557 else if( !strcasecmp( "book", lpStr
) )
559 fi
->fi_flags
|= FI_FW_BOOK
;
560 fi
->df
.dfWeight
= FW_REGULAR
;
565 if( !strcasecmp( "light", lpStr
) )
566 fi
->df
.dfWeight
= FW_LIGHT
;
567 else if( !strcasecmp( "black", lpStr
) )
568 fi
->df
.dfWeight
= FW_BLACK
;
570 else if( j
== 6 && !strcasecmp( "medium", lpStr
) )
571 fi
->df
.dfWeight
= FW_REGULAR
;
572 else if( j
== 8 && !strcasecmp( "demibold", lpStr
) )
573 fi
->df
.dfWeight
= FW_DEMIBOLD
;
575 fi
->df
.dfWeight
= FW_DONTCARE
; /* FIXME: try to get something
576 * from the weight property */
579 static BOOL
LFD_GetSlant( fontInfo
* fi
, LPCSTR lpStr
)
581 int l
= strlen(lpStr
);
584 switch( tolower( *lpStr
) )
586 case '0': fi
->fi_flags
|= FI_POLYSLANT
; /* haven't seen this one yet */
588 case 'r': fi
->df
.dfItalic
= 0;
591 fi
->fi_flags
|= FI_OBLIQUE
;
592 case 'i': fi
->df
.dfItalic
= 1;
600 static void LFD_GetStyle( fontInfo
* fi
, LPCSTR lpstr
, int dec_style_check
)
602 int j
= strlen(lpstr
);
603 if( j
> 3 ) /* find out is there "sans" or "script" */
607 if( strstr(lpstr
, "sans") )
609 fi
->df
.dfPitchAndFamily
|= FF_SWISS
;
612 if( strstr(lpstr
, "script") )
614 fi
->df
.dfPitchAndFamily
|= FF_SCRIPT
;
617 if( !j
&& dec_style_check
)
618 fi
->df
.dfPitchAndFamily
|= FF_DECORATIVE
;
622 /*************************************************************************
627 * Fill in some fields in the fontInfo struct.
629 static int LFD_InitFontInfo( fontInfo
* fi
, const LFD
* lfd
, LPCSTR fullname
)
631 int i
, j
, dec_style_check
, scalability
;
632 const fontEncodingTemplate
* boba
;
633 const char* ridiculous
= "font '%s' has ridiculous %s\n";
636 if (!lfd
->charset_registry
)
638 WARN("font '%s' does not have enough fields\n", fullname
);
642 memset(fi
, 0, sizeof(fontInfo
) );
645 LFD_GetWeight( fi
, lfd
->weight
);
648 dec_style_check
= LFD_GetSlant( fi
, lfd
->slant
);
651 lpstr
= lfd
->set_width
;
652 if( strcasecmp( "normal", lpstr
) ) /* XXX 'narrow', 'condensed', etc... */
653 dec_style_check
= TRUE
;
655 fi
->fi_flags
|= FI_NORMAL
;
658 LFD_GetStyle(fi
, lfd
->add_style
, dec_style_check
);
660 /* pixel & decipoint height, and res_x & y */
664 j
= strlen(lfd
->pixel_size
);
665 if( j
== 0 || j
> 3 )
667 WARN(ridiculous
, fullname
, "pixel_size");
670 if( !(fi
->lfd_height
= atoi(lfd
->pixel_size
)) )
673 j
= strlen(lfd
->point_size
);
674 if( j
== 0 || j
> 3 )
676 WARN(ridiculous
, fullname
, "point_size");
679 if( !(atoi(lfd
->point_size
)) )
682 j
= strlen(lfd
->resolution_x
);
683 if( j
== 0 || j
> 3 )
685 WARN(ridiculous
, fullname
, "resolution_x");
688 if( !(fi
->lfd_resolution
= atoi(lfd
->resolution_x
)) )
691 j
= strlen(lfd
->resolution_y
);
692 if( j
== 0 || j
> 3 )
694 WARN(ridiculous
, fullname
, "resolution_y");
697 if( !(atoi(lfd
->resolution_y
)) )
700 /* Check scalability */
705 case 4: /* Scalable */
706 fi
->fi_flags
|= FI_SCALABLE
;
709 /* #$%^!!! X11R6 mutant garbage (scalable bitmap) */
710 TRACE("Skipping scalable bitmap '%s'\n", fullname
);
713 WARN("Font '%s' has weird scalability\n", fullname
);
718 lpstr
= lfd
->spacing
;
722 WARN("font '%s' has no spacing\n", fullname
);
725 case 'p': fi
->fi_flags
|= FI_VARIABLEPITCH
;
727 case 'c': fi
->df
.dfPitchAndFamily
|= FF_MODERN
;
728 fi
->fi_flags
|= FI_FIXEDEX
;
730 case 'm': fi
->fi_flags
|= FI_FIXEDPITCH
;
733 /* Of course this line does nothing */
734 fi
->df
.dfPitchAndFamily
|= DEFAULT_PITCH
| FF_DONTCARE
;
737 /* average width - */
738 lpstr
= lfd
->average_width
;
740 if( j
== 0 || j
> 3 )
742 WARN(ridiculous
, fullname
, "average_width");
746 if( !(atoi(lpstr
)) && !scalability
)
748 WARN("font '%s' has average_width 0 but is not scalable!!\n", fullname
);
752 /* charset registry, charset encoding - */
753 lpstr
= lfd
->charset_registry
;
754 if( strstr(lpstr
, "ksc") ||
755 strstr(lpstr
, "gb2312") ||
756 strstr(lpstr
, "big5") )
758 FIXME("DBCS fonts like '%s' are not working correctly now.\n", fullname
);
761 fi
->df
.dfCharSet
= ANSI_CHARSET
;
763 for( i
= 0, boba
= &fETTable
[0]; boba
; boba
= boba
->next
, i
++ )
765 if (!boba
->prefix
|| !strcasecmp(lpstr
, boba
->prefix
))
767 if (lfd
->charset_encoding
)
769 for( j
= 0; boba
->sufch
[j
].psuffix
; j
++ )
771 if( !strcasecmp(lfd
->charset_encoding
, boba
->sufch
[j
].psuffix
))
773 fi
->df
.dfCharSet
= (BYTE
)(boba
->sufch
[j
].charset
& 0xff);
774 fi
->internal_charset
= boba
->sufch
[j
].charset
;
775 fi
->codepage
= boba
->sufch
[j
].codepage
;
776 fi
->cptable
= boba
->sufch
[j
].cptable
;
781 fi
->df
.dfCharSet
= (BYTE
)(boba
->sufch
[j
].charset
& 0xff);
782 fi
->internal_charset
= boba
->sufch
[j
].charset
;
783 fi
->codepage
= boba
->sufch
[j
].codepage
;
784 fi
->cptable
= boba
->sufch
[j
].cptable
;
787 FIXME("font '%s' has unknown character encoding '%s' in known registry '%s'\n",
788 fullname
, lfd
->charset_encoding
, boba
->prefix
);
793 FIXME("font '%s' has unknown registry '%s' and character encoding '%s'\n",
794 fullname
, lfd
->charset_registry
, lfd
->charset_encoding
);
798 WARN("Defaulting to: df.dfCharSet = %d, internal_charset = %d, codepage = %d, cptable = %d\n",
799 fi
->df
.dfCharSet
,fi
->internal_charset
, fi
->codepage
, fi
->cptable
);
802 else if (boba
->prefix
)
804 WARN("font '%s' has known registry '%s' and no character encoding\n",
806 for( j
= 0; boba
->sufch
[j
].psuffix
; j
++ )
808 fi
->df
.dfCharSet
= (BYTE
)(boba
->sufch
[j
].charset
& 0xff);
809 fi
->internal_charset
= boba
->sufch
[j
].charset
;
810 fi
->codepage
= boba
->sufch
[j
].codepage
;
811 fi
->cptable
= boba
->sufch
[j
].cptable
;
817 WARN("font '%s' has unknown character set '%s'\n", fullname
, lpstr
);
821 /* i - index into fETTable
822 * j - index into suffix array for fETTable[i]
824 * 254 - found encoding prefix, unknown suffix
825 * 255 - no encoding match at all.
827 fi
->fi_encoding
= 256 * (UINT16
)i
+ (UINT16
)j
;
833 /*************************************************************************
836 * make a matrix suitable for LFD based on theta radians
838 static void LFD_AngleMatrix( char* buffer
, int h
, double theta
)
841 matrix
[0] = h
*cos(theta
);
842 matrix
[1] = h
*sin(theta
);
843 matrix
[2] = -h
*sin(theta
);
844 matrix
[3] = h
*cos(theta
);
845 sprintf(buffer
, "[%+f%+f%+f%+f]", matrix
[0], matrix
[1], matrix
[2], matrix
[3]);
848 /*************************************************************************
851 * Note: uRelax is a treatment not a cure. Font mapping algorithm
852 * should be bulletproof enough to allow us to avoid hacks like
853 * this despite LFD being so braindead.
855 static BOOL
LFD_ComposeLFD( const fontObject
* fo
,
856 INT height
, LPSTR lpLFD
, UINT uRelax
)
859 const char *any
= "*";
860 char h_string
[64], resx_string
[64], resy_string
[64];
862 const fontEncodingTemplate
* boba
= &fETTable
[0];
864 /* Get the worst case over with first */
866 /* RealizeFont() will call us repeatedly with increasing uRelax
867 * until XLoadFont() succeeds.
868 * to avoid an infinite loop; these will always match
873 sprintf( lpLFD
, "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-1" );
875 sprintf( lpLFD
, "-*-*-*-*-*-*-*-*-*-*-*-*-*-*" );
879 /* read foundry + family from fo */
880 aLFD
.foundry
= fo
->fr
->resource
->foundry
;
881 aLFD
.family
= fo
->fr
->resource
->family
;
884 switch( fo
->fi
->df
.dfWeight
)
887 aLFD
.weight
= "bold"; break;
889 if( fo
->fi
->fi_flags
& FI_FW_BOOK
)
890 aLFD
.weight
= "book";
892 aLFD
.weight
= "medium";
895 aLFD
.weight
= "demi";
896 if( !( fo
->fi
->fi_flags
& FI_FW_DEMI
) )
897 aLFD
.weight
= "bold";
900 aLFD
.weight
= "black"; break;
902 aLFD
.weight
= "light"; break;
908 if( fo
->fi
->df
.dfItalic
)
909 if( fo
->fi
->fi_flags
& FI_OBLIQUE
)
914 aLFD
.slant
= (uRelax
<= 1) ? "r" : any
;
917 if( fo
->fi
->fi_flags
& FI_NORMAL
)
918 aLFD
.set_width
= "normal";
920 aLFD
.set_width
= any
;
923 aLFD
.add_style
= any
;
927 * FIXME: fill in lpXForm and lpPixmap for rotated fonts
929 if( fo
->fo_flags
& FO_SYNTH_HEIGHT
)
930 h
= fo
->fi
->lfd_height
;
933 h
= (fo
->fi
->lfd_height
* height
+ (fo
->fi
->df
.dfPixHeight
>>1));
934 h
/= fo
->fi
->df
.dfPixHeight
;
936 if (h
< MIN_FONT_SIZE
) /* Resist rounding down to 0 */
938 else if (h
> MAX_FONT_SIZE
) /* Sanity check as huge fonts can lock up the font server */
940 WARN("Huge font size %d pixels has been reduced to %d\n", h
, MAX_FONT_SIZE
);
945 /* handle rotated fonts */
946 if (fo
->lf
.lfEscapement
) {
947 /* escapement is in tenths of degrees, theta is in radians */
948 double theta
= M_PI
*fo
->lf
.lfEscapement
/1800.;
949 LFD_AngleMatrix(h_string
, h
, theta
);
953 sprintf(h_string
, "%d", h
);
956 sprintf(h_string
, "%d", fo
->fi
->lfd_height
);
958 aLFD
.pixel_size
= h_string
;
959 aLFD
.point_size
= any
;
961 /* resolution_x,y, average width */
962 /* FIXME - Why do some font servers ignore average width ?
963 * so that you have to mess around with res_y
965 aLFD
.average_width
= any
;
968 sprintf(resx_string
, "%d", fo
->fi
->lfd_resolution
);
969 aLFD
.resolution_x
= resx_string
;
971 strcpy(resy_string
, resx_string
);
972 if( uRelax
== 0 && text_caps
& TC_SF_X_YINDEP
)
974 if( fo
->lf
.lfWidth
&& !(fo
->fo_flags
& FO_SYNTH_WIDTH
))
976 int resy
= 0.5 + fo
->fi
->lfd_resolution
*
977 (fo
->fi
->df
.dfAvgWidth
* height
) /
978 (fo
->lf
.lfWidth
* fo
->fi
->df
.dfPixHeight
) ;
979 sprintf(resy_string
, "%d", resy
);
983 /* FIXME - synth width */
986 aLFD
.resolution_y
= resy_string
;
990 aLFD
.resolution_x
= aLFD
.resolution_y
= any
;
997 if( fo
->fi
->fi_flags
& FI_FIXEDPITCH
)
998 w
= ( fo
->fi
->fi_flags
& FI_FIXEDEX
) ? "c" : "m";
1000 w
= ( fo
->fi
->fi_flags
& FI_VARIABLEPITCH
) ? "p" : any
;
1002 aLFD
.spacing
= (uRelax
<= 2) ? w
: any
;
1007 for(i
= fo
->fi
->fi_encoding
>> 8; i
; i
--) boba
= boba
->next
;
1008 aLFD
.charset_registry
= boba
->prefix
? boba
->prefix
: any
;
1010 i
= fo
->fi
->fi_encoding
& 255;
1013 aLFD
.charset_encoding
= boba
->sufch
[i
].psuffix
;
1017 aLFD
.charset_encoding
= any
;
1020 case 255: /* no suffix - it ends, e.g., "-ascii" */
1021 aLFD
.charset_encoding
= NULL
;
1025 LFD_UnParse(lpLFD
, MAX_LFD_LENGTH
, &aLFD
);
1027 TRACE("\tLFD(uRelax=%d): %s\n", uRelax
, lpLFD
);
1032 /***********************************************************************
1035 static void XFONT_GetLeading( const IFONTINFO16
*pFI
, const XFontStruct
* x_fs
,
1036 INT16
* pIL
, INT16
* pEL
, const XFONTTRANS
*XFT
)
1038 unsigned long height
;
1039 unsigned min
= (unsigned char)pFI
->dfFirstChar
;
1040 unsigned max
= (unsigned char)pFI
->dfLastChar
;
1041 BOOL bIsLatin
= IS_LATIN_CHARSET(pFI
->dfCharSet
);
1047 if(XGetFontProperty((XFontStruct
*)x_fs
, x11drv_atom(RAW_CAP_HEIGHT
), &height
))
1048 *pIL
= XFT
->ascent
-
1049 (INT
)(XFT
->pixelsize
/ 1000.0 * height
);
1052 wine_tsx11_unlock();
1057 if( XGetFontProperty((XFontStruct
*)x_fs
, XA_CAP_HEIGHT
, &height
) == FALSE
)
1059 if( x_fs
->per_char
)
1060 if( bIsLatin
&& ((unsigned char)'X' <= (max
- min
)) )
1061 height
= x_fs
->per_char
['X' - min
].ascent
;
1063 if (x_fs
->ascent
>= x_fs
->max_bounds
.ascent
)
1064 height
= x_fs
->max_bounds
.ascent
;
1067 height
= x_fs
->ascent
;
1069 *pEL
= x_fs
->max_bounds
.ascent
- height
;
1072 height
= x_fs
->min_bounds
.ascent
;
1074 wine_tsx11_unlock();
1076 *pIL
= x_fs
->ascent
- height
;
1079 /***********************************************************************
1082 static int XFONT_CharWidth(const XFontStruct
* x_fs
,
1083 const XFONTTRANS
*XFT
, int ch
)
1086 return x_fs
->per_char
[ch
].width
;
1088 return x_fs
->per_char
[ch
].attributes
* XFT
->pixelsize
/ 1000.0;
1091 /***********************************************************************
1092 * XFONT_GetAvgCharWidth
1094 static INT
XFONT_GetAvgCharWidth( LPIFONTINFO16 pFI
, const XFontStruct
* x_fs
,
1095 const XFONTTRANS
*XFT
)
1097 unsigned min
= (unsigned char)pFI
->dfFirstChar
;
1098 unsigned max
= (unsigned char)pFI
->dfLastChar
;
1102 if( x_fs
->per_char
)
1104 unsigned int width
= 0, chars
= 0, j
;
1105 if( (IS_LATIN_CHARSET(pFI
->dfCharSet
) ||
1106 pFI
->dfCharSet
== DEFAULT_CHARSET
) &&
1107 (max
- min
) >= (unsigned char)'z' )
1109 /* FIXME - should use a weighted average */
1110 for( j
= 0; j
< 26; j
++ )
1111 width
+= XFONT_CharWidth(x_fs
, XFT
, 'a' + j
- min
) +
1112 XFONT_CharWidth(x_fs
, XFT
, 'A' + j
- min
);
1115 else /* unweighted average of everything */
1117 for( j
= 0, max
-= min
; j
<= max
; j
++ )
1118 if( !CI_NONEXISTCHAR(x_fs
->per_char
+ j
) )
1120 width
+= XFONT_CharWidth(x_fs
, XFT
, j
);
1124 if (chars
) avg
= (width
+ (chars
-1))/ chars
; /* always round up*/
1125 else avg
= 0; /* No characters exist at all */
1127 else /* uniform width */
1128 avg
= x_fs
->min_bounds
.width
;
1130 TRACE(" retuning %d\n",avg
);
1134 /***********************************************************************
1135 * XFONT_GetMaxCharWidth
1137 static INT
XFONT_GetMaxCharWidth(const XFontStruct
* xfs
, const XFONTTRANS
*XFT
)
1139 unsigned min
= (unsigned char)xfs
->min_char_or_byte2
;
1140 unsigned max
= (unsigned char)xfs
->max_char_or_byte2
;
1141 unsigned int maxwidth
, j
;
1143 if(!XFT
|| !xfs
->per_char
)
1144 return abs(xfs
->max_bounds
.width
);
1146 for( j
= 0, maxwidth
= 0, max
-= min
; j
<= max
; j
++ )
1147 if( !CI_NONEXISTCHAR(xfs
->per_char
+ j
) )
1148 if(maxwidth
< xfs
->per_char
[j
].attributes
)
1149 maxwidth
= xfs
->per_char
[j
].attributes
;
1151 maxwidth
*= XFT
->pixelsize
/ 1000.0;
1155 /***********************************************************************
1156 * XFONT_SetFontMetric
1160 * Initializes IFONTINFO16.
1162 static void XFONT_SetFontMetric(fontInfo
* fi
, const fontResource
* fr
, XFontStruct
* xfs
)
1165 fi
->df
.dfFirstChar
= (BYTE
)(min
= xfs
->min_char_or_byte2
);
1166 fi
->df
.dfLastChar
= (BYTE
)(max
= xfs
->max_char_or_byte2
);
1168 fi
->df
.dfDefaultChar
= (BYTE
)xfs
->default_char
;
1169 fi
->df
.dfBreakChar
= (BYTE
)(( ' ' < min
|| ' ' > max
) ? xfs
->default_char
: ' ');
1171 fi
->df
.dfPixHeight
= (INT16
)((fi
->df
.dfAscent
= (INT16
)xfs
->ascent
) + xfs
->descent
);
1172 fi
->df
.dfPixWidth
= (xfs
->per_char
) ? 0 : xfs
->min_bounds
.width
;
1174 XFONT_GetLeading( &fi
->df
, xfs
, &fi
->df
.dfInternalLeading
, &fi
->df
.dfExternalLeading
, NULL
);
1175 fi
->df
.dfAvgWidth
= (INT16
)XFONT_GetAvgCharWidth(&fi
->df
, xfs
, NULL
);
1176 fi
->df
.dfMaxWidth
= (INT16
)XFONT_GetMaxCharWidth(xfs
, NULL
);
1178 if( xfs
->min_bounds
.width
!= xfs
->max_bounds
.width
)
1179 fi
->df
.dfPitchAndFamily
|= TMPF_FIXED_PITCH
; /* au contraire! */
1180 if( fi
->fi_flags
& FI_SCALABLE
)
1182 fi
->df
.dfType
= DEVICE_FONTTYPE
;
1183 fi
->df
.dfPitchAndFamily
|= TMPF_DEVICE
;
1185 else if( fi
->fi_flags
& FI_TRUETYPE
)
1186 fi
->df
.dfType
= TRUETYPE_FONTTYPE
;
1188 fi
->df
.dfType
= RASTER_FONTTYPE
;
1190 fi
->df
.dfFace
= fr
->lfFaceName
;
1193 /***********************************************************************
1194 * XFONT_GetFontMetric
1196 * Retrieve font metric info (enumeration).
1198 static UINT
XFONT_GetFontMetric( const fontInfo
* pfi
,
1199 LPENUMLOGFONTEXW pLF
,
1200 NEWTEXTMETRICEXW
*pTM
)
1202 memset( pLF
, 0, sizeof(*pLF
) );
1203 memset( pTM
, 0, sizeof(*pTM
) );
1205 #define plf ((LPLOGFONTW)pLF)
1206 #define ptm ((LPNEWTEXTMETRICW)pTM)
1207 plf
->lfHeight
= ptm
->tmHeight
= pfi
->df
.dfPixHeight
;
1208 plf
->lfWidth
= ptm
->tmAveCharWidth
= pfi
->df
.dfAvgWidth
;
1209 plf
->lfWeight
= ptm
->tmWeight
= pfi
->df
.dfWeight
;
1210 plf
->lfItalic
= ptm
->tmItalic
= pfi
->df
.dfItalic
;
1211 plf
->lfUnderline
= ptm
->tmUnderlined
= pfi
->df
.dfUnderline
;
1212 plf
->lfStrikeOut
= ptm
->tmStruckOut
= pfi
->df
.dfStrikeOut
;
1213 plf
->lfCharSet
= ptm
->tmCharSet
= pfi
->df
.dfCharSet
;
1215 /* convert pitch values */
1217 ptm
->tmPitchAndFamily
= pfi
->df
.dfPitchAndFamily
;
1218 plf
->lfPitchAndFamily
= (pfi
->df
.dfPitchAndFamily
& 0xF1) + 1;
1220 MultiByteToWideChar(CP_ACP
, 0, pfi
->df
.dfFace
, -1,
1221 plf
->lfFaceName
, LF_FACESIZE
);
1223 /* FIXME: fill in rest of plF values */
1224 strcpyW(pLF
->elfFullName
, plf
->lfFaceName
);
1225 MultiByteToWideChar(CP_ACP
, 0, "Regular", -1,
1226 pLF
->elfStyle
, LF_FACESIZE
);
1227 MultiByteToWideChar(CP_ACP
, 0, plf
->lfCharSet
== SYMBOL_CHARSET
?
1228 "Symbol" : "Roman", -1,
1229 pLF
->elfScript
, LF_FACESIZE
);
1233 ptm
->tmAscent
= pfi
->df
.dfAscent
;
1234 ptm
->tmDescent
= ptm
->tmHeight
- ptm
->tmAscent
;
1235 ptm
->tmInternalLeading
= pfi
->df
.dfInternalLeading
;
1236 ptm
->tmMaxCharWidth
= pfi
->df
.dfMaxWidth
;
1237 ptm
->tmDigitizedAspectX
= pfi
->df
.dfHorizRes
;
1238 ptm
->tmDigitizedAspectY
= pfi
->df
.dfVertRes
;
1240 ptm
->tmFirstChar
= pfi
->df
.dfFirstChar
;
1241 ptm
->tmLastChar
= pfi
->df
.dfLastChar
;
1242 ptm
->tmDefaultChar
= pfi
->df
.dfDefaultChar
;
1243 ptm
->tmBreakChar
= pfi
->df
.dfBreakChar
;
1245 TRACE("Calling Enum proc with FaceName %s FullName %s\n",
1246 debugstr_w(pLF
->elfLogFont
.lfFaceName
),
1247 debugstr_w(pLF
->elfFullName
));
1249 TRACE("CharSet = %d type = %d\n", ptm
->tmCharSet
, pfi
->df
.dfType
);
1250 /* return font type */
1251 return pfi
->df
.dfType
;
1256 /***********************************************************************
1261 * dfPitchAndFamily flags for some common typefaces.
1263 static BYTE
XFONT_FixupFlags( LPCSTR lfFaceName
)
1265 switch( lfFaceName
[0] )
1268 case 'A': if(!strncasecmp(lfFaceName
, "Arial", 5) )
1272 case 'H': if(!strcasecmp(lfFaceName
, "Helvetica") )
1276 case 'C': if(!strncasecmp(lfFaceName
, "Courier", 7))
1279 if (!strcasecmp(lfFaceName
, "Charter") )
1283 case 'P': if( !strcasecmp(lfFaceName
,"Palatino") )
1287 case 'T': if(!strncasecmp(lfFaceName
, "Times", 5) )
1291 case 'U': if(!strcasecmp(lfFaceName
, "Utopia") )
1295 case 'Z': if(!strcasecmp(lfFaceName
, "Zapf Dingbats") )
1296 return FF_DECORATIVE
;
1301 /***********************************************************************
1302 * XFONT_SameFoundryAndFamily
1306 static BOOL
XFONT_SameFoundryAndFamily( const LFD
* lfd1
, const LFD
* lfd2
)
1308 return ( !strcasecmp( lfd1
->foundry
, lfd2
->foundry
) &&
1309 !strcasecmp( lfd1
->family
, lfd2
->family
) );
1312 /***********************************************************************
1313 * XFONT_InitialCapitals
1317 * Upper case first letters of words & remove multiple spaces
1319 static void XFONT_InitialCapitals(LPSTR lpch
)
1325 for( i
= 0, up
= TRUE
; *lpch
; lpch
++, i
++ )
1327 if( isspace(*lpch
) )
1329 if (!up
) /* Not already got one */
1335 else if( isalpha(*lpch
) && up
)
1337 *lpstr
++ = toupper(*lpch
);
1347 /* Remove possible trailing space */
1354 /***********************************************************************
1355 * XFONT_WindowsNames
1359 * Build generic Windows aliases for X font names.
1361 * -misc-fixed- -> "Fixed"
1362 * -sony-fixed- -> "Sony Fixed", etc...
1364 static void XFONT_WindowsNames(void)
1368 for( fr
= fontList
; fr
; fr
= fr
->next
)
1372 if( fr
->fr_flags
& FR_NAMESET
) continue; /* skip already assigned */
1374 for( pfr
= fontList
; pfr
!= fr
; pfr
= pfr
->next
)
1375 if( pfr
->fr_flags
& FR_NAMESET
)
1377 if (!strcasecmp( pfr
->resource
->family
, fr
->resource
->family
))
1381 snprintf( fr
->lfFaceName
, sizeof(fr
->lfFaceName
), "%s %s",
1382 /* prepend vendor name */
1383 (pfr
==fr
) ? "" : fr
->resource
->foundry
,
1384 fr
->resource
->family
);
1385 XFONT_InitialCapitals(fr
->lfFaceName
);
1387 BYTE bFamilyStyle
= XFONT_FixupFlags( fr
->lfFaceName
);
1391 for( fi
= fr
->fi
; fi
; fi
= fi
->next
)
1392 fi
->df
.dfPitchAndFamily
|= bFamilyStyle
;
1396 TRACE("typeface '%s'\n", fr
->lfFaceName
);
1398 fr
->fr_flags
|= FR_NAMESET
;
1402 /***********************************************************************
1403 * XFONT_LoadDefaultLFD
1405 * Move lfd to the head of fontList to make it more likely to be matched
1407 static void XFONT_LoadDefaultLFD(LFD
* lfd
, LPCSTR fonttype
)
1410 fontResource
*fr
, *pfr
;
1411 for( fr
= NULL
, pfr
= fontList
; pfr
; pfr
= pfr
->next
)
1413 if( XFONT_SameFoundryAndFamily(pfr
->resource
, lfd
) )
1417 fr
->next
= pfr
->next
;
1418 pfr
->next
= fontList
;
1426 WARN("Default %sfont '-%s-%s-' not available\n", fonttype
,
1427 lfd
->foundry
, lfd
->family
);
1431 /***********************************************************************
1434 static void XFONT_LoadDefault( HKEY hkey
, LPCSTR ini
, LPCSTR fonttype
)
1436 char buffer
[MAX_LFD_LENGTH
];
1437 DWORD type
, count
= sizeof(buffer
);
1440 RegQueryValueExA(hkey
, ini
, 0, &type
, (LPBYTE
)buffer
, &count
);
1446 while( *pch
&& isspace(*pch
) ) pch
++;
1448 TRACE("Using '%s' as default %sfont\n", pch
, fonttype
);
1449 if (LFD_Parse(pch
, &lfd
) && lfd
.foundry
&& lfd
.family
)
1450 XFONT_LoadDefaultLFD(&lfd
, fonttype
);
1452 WARN("Ini section [%s]%s is malformed\n", INIFontSection
, ini
);
1456 /***********************************************************************
1457 * XFONT_LoadDefaults
1459 static void XFONT_LoadDefaults( HKEY hkey
)
1461 XFONT_LoadDefault( hkey
, INIDefaultFixed
, "fixed ");
1462 XFONT_LoadDefault( hkey
, INIDefault
, "");
1465 /***********************************************************************
1468 static fontAlias
* XFONT_CreateAlias( LPCSTR lpTypeFace
, LPCSTR lpAlias
)
1471 fontAlias
*pfa
, *prev
= NULL
;
1473 for(pfa
= aliasTable
; pfa
; pfa
= pfa
->next
)
1475 /* check if we already got one */
1476 if( !strcasecmp( pfa
->faTypeFace
, lpAlias
) )
1478 TRACE("redundant alias '%s' -> '%s'\n",
1479 lpAlias
, lpTypeFace
);
1485 j
= strlen(lpTypeFace
) + 1;
1486 pfa
= HeapAlloc( GetProcessHeap(), 0, sizeof(fontAlias
) +
1487 j
+ strlen(lpAlias
) + 1 );
1496 pfa
->faTypeFace
= (LPSTR
)(pfa
+ 1);
1497 strcpy( pfa
->faTypeFace
, lpTypeFace
);
1498 pfa
->faAlias
= pfa
->faTypeFace
+ j
;
1499 strcpy( pfa
->faAlias
, lpAlias
);
1501 TRACE("added alias '%s' for '%s'\n", lpAlias
, lpTypeFace
);
1509 /***********************************************************************
1512 static void XFONT_LoadAlias(const LFD
* lfd
, LPCSTR lpAlias
, BOOL bSubst
)
1514 fontResource
*fr
, *frMatch
= NULL
;
1515 if (!lfd
->foundry
|| ! lfd
->family
)
1517 WARN("Malformed font resource for alias '%s'\n", lpAlias
);
1520 for (fr
= fontList
; fr
; fr
= fr
->next
)
1522 if(!strcasecmp(fr
->resource
->family
, lpAlias
))
1524 /* alias is not needed since the real font is present */
1525 TRACE("Ignoring font alias '%s' as it is already available as a real font\n", lpAlias
);
1528 if( XFONT_SameFoundryAndFamily( fr
->resource
, lfd
) )
1539 fontAlias
*pfa
, *prev
= NULL
;
1541 for(pfa
= aliasTable
; pfa
; pfa
= pfa
->next
)
1543 /* Remove lpAlias from aliasTable - we should free the old entry */
1544 if(!strcmp(lpAlias
, pfa
->faAlias
))
1547 prev
->next
= pfa
->next
;
1549 aliasTable
= pfa
->next
;
1552 /* Update any references to the substituted font in aliasTable */
1553 if(!strcmp(frMatch
->lfFaceName
, pfa
->faTypeFace
))
1555 pfa
->faTypeFace
= HeapAlloc( GetProcessHeap(), 0, strlen(lpAlias
)+1 );
1556 strcpy( pfa
->faTypeFace
, lpAlias
);
1561 TRACE("\tsubstituted '%s' with '%s'\n", frMatch
->lfFaceName
, lpAlias
);
1563 lstrcpynA( frMatch
->lfFaceName
, lpAlias
, LF_FACESIZE
);
1564 frMatch
->fr_flags
|= FR_NAMESET
;
1568 /* create new entry in the alias table */
1569 XFONT_CreateAlias( frMatch
->lfFaceName
, lpAlias
);
1574 WARN("Font alias '-%s-%s-' is not available\n", lfd
->foundry
, lfd
->family
);
1578 /***********************************************************************
1579 * Just a copy of PROFILE_GetStringItem
1581 * Convenience function that turns a string 'xxx, yyy, zzz' into
1582 * the 'xxx\0 yyy, zzz' and returns a pointer to the 'yyy, zzz'.
1584 static char *XFONT_GetStringItem( char *start
)
1586 #define XFONT_isspace(c) (isspace(c) || (c == '\r') || (c == 0x1a))
1589 for (lpchX
= start
, lpch
= NULL
; *lpchX
!= '\0'; lpchX
++ )
1593 if( lpch
) *lpch
= '\0'; else *lpchX
= '\0';
1595 if( !XFONT_isspace(*lpchX
) ) return lpchX
;
1597 else if( XFONT_isspace( *lpchX
) && !lpch
) lpch
= lpchX
;
1600 if( lpch
) *lpch
= '\0';
1602 #undef XFONT_isspace
1605 /***********************************************************************
1610 * Create font aliases for some standard windows fonts using user's
1611 * default choice of (sans-)serif fonts
1613 * Read user-defined aliases from config file. Format is as follows
1615 * Alias# = [Windows font name],[LFD font name], <substitute original name>
1618 * Alias0 = Arial, -adobe-helvetica-
1619 * Alias1 = Times New Roman, -bitstream-courier-, 1
1622 * Note that from 970817 and on we have built-in alias templates that take
1623 * care of the necessary Windows typefaces.
1631 static void XFONT_LoadAliases( HKEY hkey
)
1634 char buffer
[MAX_LFD_LENGTH
];
1638 /* built-ins first */
1639 strcpy(buffer
, "-bitstream-charter-");
1642 DWORD type
, count
= sizeof(buffer
);
1643 RegQueryValueExA(hkey
, INIDefaultSerif
, 0, &type
, (LPBYTE
)buffer
, &count
);
1645 TRACE("Using '%s' as default serif font\n", buffer
);
1646 if (LFD_Parse(buffer
, &lfd
))
1648 /* NB XFONT_InitialCapitals should not change these standard aliases */
1649 XFONT_LoadAlias( &lfd
, "Tms Roman", FALSE
);
1650 XFONT_LoadAlias( &lfd
, "MS Serif", FALSE
);
1651 XFONT_LoadAlias( &lfd
, "Times New Roman", FALSE
);
1653 XFONT_LoadDefaultLFD( &lfd
, "serif ");
1656 strcpy(buffer
, "-adobe-helvetica-");
1659 DWORD type
, count
= sizeof(buffer
);
1660 RegQueryValueExA(hkey
, INIDefaultSansSerif
, 0, &type
, (LPBYTE
)buffer
, &count
);
1662 TRACE("Using '%s' as default sans serif font\n", buffer
);
1663 if (LFD_Parse(buffer
, &lfd
))
1665 XFONT_LoadAlias( &lfd
, "Helv", FALSE
);
1666 XFONT_LoadAlias( &lfd
, "MS Sans Serif", FALSE
);
1667 XFONT_LoadAlias( &lfd
, "MS Shell Dlg", FALSE
);
1668 XFONT_LoadAlias( &lfd
, "System", FALSE
);
1669 XFONT_LoadAlias( &lfd
, "Arial", FALSE
);
1671 XFONT_LoadDefaultLFD( &lfd
, "sans serif ");
1674 /* then user specified aliases */
1677 char subsection
[32];
1678 snprintf( subsection
, sizeof(subsection
), "%s%i", INIAliasSection
, i
++ );
1683 DWORD type
, count
= sizeof(buffer
);
1684 RegQueryValueExA(hkey
, subsection
, 0, &type
, (LPBYTE
)buffer
, &count
);
1690 XFONT_InitialCapitals(buffer
);
1691 lpResource
= XFONT_GetStringItem( buffer
);
1692 if( lpResource
&& *lpResource
)
1694 BOOL bSubst
= (XFONT_GetStringItem( lpResource
)) ? TRUE
: FALSE
;
1695 if (LFD_Parse(lpResource
, &lfd
)) XFONT_LoadAlias(&lfd
, buffer
, bSubst
);
1698 WARN("malformed font alias '%s'\n", buffer
);
1703 /***********************************************************************
1706 * Convert an (potential) alias into a real windows name
1709 static LPCSTR
XFONT_UnAlias(char* font
)
1714 XFONT_InitialCapitals(font
); /* to remove extra white space */
1716 for( fa
= aliasTable
; fa
; fa
= fa
->next
)
1717 /* use case insensitive matching to handle, e.g., "MS Sans Serif" */
1718 if( !strcasecmp( fa
->faAlias
, font
) )
1720 TRACE("found alias '%s'->%s'\n", font
, fa
->faTypeFace
);
1721 strcpy(font
, fa
->faTypeFace
);
1728 /***********************************************************************
1729 * XFONT_RemoveFontResource
1731 * Caller should check if the font resource is in use. If it is it should
1732 * set FR_REMOVED flag to delay removal until the resource is not in use
1735 static void XFONT_RemoveFontResource( fontResource
** ppfr
)
1737 fontResource
* pfr
= *ppfr
;
1741 /* FIXME - if fonts were read from a cache, these HeapFrees will fail */
1744 pfi
= pfr
->fi
->next
;
1745 HeapFree( GetProcessHeap(), 0, pfr
->fi
);
1748 HeapFree( GetProcessHeap(), 0, pfr
);
1753 /***********************************************************************
1758 * Removes specified fonts from the font table to prevent Wine from
1761 * Ignore# = [LFD font name]
1764 * Ignore0 = -misc-nil-
1765 * Ignore1 = -sun-open look glyph-
1769 static void XFONT_LoadIgnore(char* lfdname
)
1771 fontResource
** ppfr
;
1774 if (LFD_Parse(lfdname
, &lfd
) && lfd
.foundry
&& lfd
.family
)
1776 for( ppfr
= &fontList
; *ppfr
; ppfr
= &((*ppfr
)->next
))
1778 if( XFONT_SameFoundryAndFamily( (*ppfr
)->resource
, &lfd
) )
1780 TRACE("Ignoring '-%s-%s-'\n",
1781 (*ppfr
)->resource
->foundry
, (*ppfr
)->resource
->family
);
1783 XFONT_RemoveFontResource( ppfr
);
1789 WARN("Malformed font resource\n");
1792 static void XFONT_LoadIgnores( HKEY hkey
)
1795 char subsection
[32];
1796 char buffer
[MAX_LFD_LENGTH
];
1798 /* Standard one that no one wants */
1799 strcpy(buffer
, "-misc-nil-");
1800 XFONT_LoadIgnore(buffer
);
1802 /* Others from INI file */
1806 DWORD type
, count
= sizeof(buffer
);
1807 sprintf( subsection
, "%s%i", INIIgnoreSection
, i
++ );
1809 if (!RegQueryValueExA(hkey
, subsection
, 0, &type
, (LPBYTE
)buffer
, &count
))
1812 while( *pch
&& isspace(*pch
) ) pch
++;
1813 XFONT_LoadIgnore(pch
);
1821 /***********************************************************************
1822 * XFONT_UserMetricsCache
1824 * Returns expanded name for the cachedmetrics file.
1825 * Now it also appends the current value of the $DISPLAY variable.
1827 static char* XFONT_UserMetricsCache(void)
1829 const char *confdir
= wine_get_config_dir();
1830 const char *display_name
= XDisplayName(NULL
);
1831 int len
= strlen(confdir
) + strlen(INIFontMetrics
) + strlen(display_name
) + 8;
1833 unsigned int display
= 0;
1834 unsigned int screen
= 0;
1837 if (!(buffer
= HeapAlloc(GetProcessHeap(), 0, len
)))
1839 ERR("out of memory\n");
1842 sprintf( buffer
, "%s/%s", confdir
, INIFontMetrics
);
1844 ext
= buffer
+ strlen(buffer
);
1845 strcpy( ext
, display_name
);
1848 ** Normalize the display name. The format of DISPLAY is
1849 ** [protocol/] [hostname] :[:] num [.num]
1851 ** - on Red Hat systems, DISPLAY is commonly set to one of
1852 ** either 'unix:0.0' or ':0' or ':0.0'.
1853 ** - on Mac OS X systems, DISPLAY is commonly set to
1856 ** after this code, all of the above will resolve to ':0.0'.
1858 p
= strrchr(ext
, ':');
1861 sscanf(p
+ 1, "%u.%u", &display
, &screen
);
1865 WARN("unlikely X11 display number\n");
1870 if (!strcmp( ext
, "unix" ) ||
1871 !strcmp( ext
, "localhost" ))
1873 if (!strncmp( ext
, "/tmp/", 5 ))
1874 *ext
= 0; /* assume pathnames are local */
1876 /* Deal with the possibility of slashes in the display name */
1877 for( p
= ext
; *p
; p
++ )
1881 /* X11 fonts are per-display, not per-screen, so don't
1882 ** include the screen number in the font cache filename */
1883 sprintf( ext
+ strlen(ext
), ":%u", display
);
1885 TRACE("display '%s' -> cachefile '%s'\n", display_name
, buffer
);
1891 /***********************************************************************
1894 * Compare two fonts (only parameters set by the XFONT_InitFontInfo()).
1896 static INT
XFONT_IsSubset(const fontInfo
* match
, const fontInfo
* fi
)
1900 /* 0 - keep both, 1 - keep match, -1 - keep fi */
1902 /* Compare dfItalic, Underline, Strikeout, Weight, Charset */
1903 m
= (const BYTE
*)&fi
->df
.dfPixWidth
- (const BYTE
*)&fi
->df
.dfItalic
;
1904 if( memcmp(&match
->df
.dfItalic
, &fi
->df
.dfItalic
, m
)) return 0;
1906 if( (!((fi
->fi_flags
& FI_SCALABLE
) + (match
->fi_flags
& FI_SCALABLE
))
1907 && fi
->lfd_height
!= match
->lfd_height
) ||
1908 (!((fi
->fi_flags
& FI_POLYWEIGHT
) + (match
->fi_flags
& FI_POLYWEIGHT
))
1909 && fi
->df
.dfWeight
!= match
->df
.dfWeight
) ) return 0;
1911 m
= (int)(match
->fi_flags
& (FI_POLYWEIGHT
| FI_SCALABLE
)) -
1912 (int)(fi
->fi_flags
& (FI_SCALABLE
| FI_POLYWEIGHT
));
1914 if( m
== (FI_POLYWEIGHT
- FI_SCALABLE
) ||
1915 m
== (FI_SCALABLE
- FI_POLYWEIGHT
) ) return 0; /* keep both */
1916 else if( m
>= 0 ) return 1; /* 'match' is better */
1918 return -1; /* 'fi' is better */
1921 /***********************************************************************
1924 * REMOVE_SUBSETS - attach new fi and purge subsets
1925 * UNMARK_SUBSETS - remove subset flags from all fi entries
1927 static void XFONT_CheckFIList( fontResource
* fr
, fontInfo
* fi
, int action
)
1930 fontInfo
* pfi
, *prev
;
1932 for( prev
= NULL
, pfi
= fr
->fi
; pfi
; )
1934 if( action
== REMOVE_SUBSETS
)
1936 if( pfi
->fi_flags
& FI_SUBSET
)
1938 fontInfo
* subset
= pfi
;
1942 if( prev
) prev
->next
= pfi
= pfi
->next
;
1943 else fr
->fi
= pfi
= pfi
->next
;
1944 HeapFree( GetProcessHeap(), 0, subset
);
1948 else pfi
->fi_flags
&= ~FI_SUBSET
;
1954 if( action
== REMOVE_SUBSETS
) /* also add the superset */
1956 if( fi
->fi_flags
& FI_SCALABLE
)
1961 else if( prev
) prev
->next
= fi
; else fr
->fi
= fi
;
1965 if( i
) TRACE("\t purged %i subsets [%i]\n", i
, fr
->fi_count
);
1968 /***********************************************************************
1971 static fontResource
* XFONT_FindFIList( fontResource
* pfr
, const char* pTypeFace
)
1975 if( !strcasecmp( pfr
->lfFaceName
, pTypeFace
) ) break;
1978 /* Give the app back the font name it asked for. Encarta checks this. */
1979 if (pfr
) strcpy(pfr
->lfFaceName
,pTypeFace
);
1983 /***********************************************************************
1984 * XFONT_FixupPointSize
1986 static void XFONT_FixupPointSize(fontInfo
* fi
)
1989 df
.dfHorizRes
= df
.dfVertRes
= fi
->lfd_resolution
;
1990 df
.dfPoints
= (INT16
)
1991 (((INT
)(df
.dfPixHeight
- df
.dfInternalLeading
) * 72 + (df
.dfVertRes
>> 1)) /
1996 /***********************************************************************
1997 * XFONT_BuildMetrics
1999 * Build font metrics from X font
2001 static int XLoadQueryFont_ErrorHandler(Display
*dpy
, XErrorEvent
*event
, void *arg
)
2006 /* XLoadQueryFont has the bad habit of crashing when loading a bad font... */
2007 static XFontStruct
*safe_XLoadQueryFont(Display
*display
, char *name
)
2011 X11DRV_expect_error(display
, XLoadQueryFont_ErrorHandler
, NULL
);
2012 ret
= XLoadQueryFont(display
, name
);
2013 if (X11DRV_check_error()) ret
= NULL
;
2018 static int XFONT_BuildMetrics(char** x_pattern
, int res
, unsigned x_checksum
, int x_count
)
2021 fontInfo
* fi
= NULL
;
2022 fontResource
* fr
, *pfr
;
2025 MESSAGE("Building font metrics. This may take some time...\n");
2026 for( i
= 0; i
< x_count
; i
++ )
2031 char buffer
[MAX_LFD_LENGTH
];
2036 if (!(typeface
= HeapAlloc(GetProcessHeap(), 0, strlen(x_pattern
[i
])+1))) break;
2037 strcpy( typeface
, x_pattern
[i
] );
2038 if (i
% 10 == 0) MESSAGE("Font metrics: %.1f%% done\n", 100.0 * i
/ x_count
);
2040 if (!LFD_Parse(typeface
, &lfd
))
2042 HeapFree(GetProcessHeap(), 0, typeface
);
2046 /* find a family to insert into */
2048 for( pfr
= NULL
, fr
= fontList
; fr
; fr
= fr
->next
)
2050 if( XFONT_SameFoundryAndFamily(fr
->resource
, &lfd
))
2055 if( !fi
) fi
= HeapAlloc(GetProcessHeap(), 0, sizeof(fontInfo
));
2057 if( !LFD_InitFontInfo( fi
, &lfd
, x_pattern
[i
]) )
2060 if( !fr
) /* add new family */
2063 fr
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(fontResource
));
2066 fr
->resource
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(LFD
));
2068 TRACE("family: -%s-%s-\n", lfd
.foundry
, lfd
.family
);
2069 fr
->resource
->foundry
= HeapAlloc(GetProcessHeap(), 0, strlen(lfd
.foundry
)+1);
2070 strcpy( (char *)fr
->resource
->foundry
, lfd
.foundry
);
2071 fr
->resource
->family
= HeapAlloc(GetProcessHeap(), 0, strlen(lfd
.family
)+1);
2072 strcpy( (char *)fr
->resource
->family
, lfd
.family
);
2073 fr
->resource
->weight
= "";
2075 if( pfr
) pfr
->next
= fr
;
2079 WARN("Not enough memory for a new font family\n");
2082 /* check if we already have something better than "fi" */
2084 for( pfi
= fr
->fi
, j
= 0; pfi
&& j
<= 0; pfi
= pfi
->next
)
2085 if( (j
= XFONT_IsSubset( pfi
, fi
)) < 0 )
2086 pfi
->fi_flags
|= FI_SUBSET
; /* superseded by "fi" */
2087 if( j
> 0 ) goto nextfont
;
2089 /* add new font instance "fi" to the "fr" font resource */
2091 if( fi
->fi_flags
& FI_SCALABLE
)
2094 char pxl_string
[4], res_string
[4];
2095 /* set scalable font height to get a basis for extrapolation */
2097 fi
->lfd_height
= DEF_SCALABLE_HEIGHT
;
2098 fi
->lfd_resolution
= res
;
2100 sprintf(pxl_string
, "%d", fi
->lfd_height
);
2101 sprintf(res_string
, "%d", fi
->lfd_resolution
);
2104 lfd1
.pixel_size
= pxl_string
;
2105 lfd1
.point_size
= "*";
2106 lfd1
.resolution_x
= res_string
;
2107 lfd1
.resolution_y
= res_string
;
2109 LFD_UnParse(buffer
, sizeof(buffer
), &lfd1
);
2113 else lpstr
= x_pattern
[i
];
2115 /* X11 may return an error on some bad fonts... So be prepared to handle these. */
2116 if ((x_fs
= safe_XLoadQueryFont(gdi_display
, lpstr
)) != 0)
2118 XFONT_SetFontMetric( fi
, fr
, x_fs
);
2120 XFreeFont( gdi_display
, x_fs
);
2121 wine_tsx11_unlock();
2123 XFONT_FixupPointSize(fi
);
2125 TRACE("\t[% 2ipt] '%s'\n", fi
->df
.dfPoints
, x_pattern
[i
] );
2127 XFONT_CheckFIList( fr
, fi
, REMOVE_SUBSETS
);
2128 fi
= NULL
; /* preventing reuse */
2132 ERR("failed to load %s\n", lpstr
);
2134 XFONT_CheckFIList( fr
, fi
, UNMARK_SUBSETS
);
2137 HeapFree(GetProcessHeap(), 0, typeface
);
2139 HeapFree(GetProcessHeap(), 0, fi
);
2141 /* Scan through the font list and remove FontResource(s) (fr)
2142 * that have no associated Fontinfo(s) (fi).
2143 * This code is necessary because XFONT_ReadCachedMetrics
2144 * assumes that there is at least one fi associated with a fr.
2145 * This assumption is invalid for TT font
2146 * -altsys-ms outlook-medium-r-normal--0-0-0-0-p-0-microsoft-symbol.
2151 while (!fr
->fi_count
)
2153 fontList
= fr
->next
;
2155 HeapFree(GetProcessHeap(), 0, fr
->resource
);
2156 HeapFree(GetProcessHeap(), 0, fr
);
2166 if (!fr
->next
->fi_count
)
2169 fr
->next
= fr
->next
->next
;
2171 HeapFree(GetProcessHeap(), 0, pfr
->resource
);
2172 HeapFree(GetProcessHeap(), 0, pfr
);
2180 MESSAGE("Font metrics: 100.0%% done\n");
2184 /***********************************************************************
2185 * XFONT_ReadCachedMetrics
2189 static BOOL
XFONT_ReadCachedMetrics( const char *path
, int res
, unsigned x_checksum
, int x_count
)
2191 int fd
= open( path
, O_RDONLY
);
2198 /* read checksums */
2199 read( fd
, &u
, sizeof(unsigned) );
2200 read( fd
, &i
, sizeof(int) );
2202 if( u
== x_checksum
&& i
== x_count
)
2204 off_t length
, offset
= 3 * sizeof(int);
2206 /* read total size */
2207 read( fd
, &i
, sizeof(int) );
2208 length
= lseek( fd
, 0, SEEK_END
);
2210 if( length
== (i
+ offset
) )
2212 lseek( fd
, offset
, SEEK_SET
);
2213 fontList
= HeapAlloc( GetProcessHeap(), 0, i
);
2216 fontResource
* pfr
= fontList
;
2217 fontInfo
* pfi
= NULL
;
2219 TRACE("Reading cached font metrics:\n");
2221 read( fd
, fontList
, i
); /* read all metrics at once */
2222 while( offset
< length
)
2224 offset
+= sizeof(fontResource
) + sizeof(fontInfo
);
2225 pfr
->fi
= pfi
= (fontInfo
*)(pfr
+ 1);
2229 if( offset
> length
||
2230 pfi
->cptable
>= (UINT16
)X11DRV_CPTABLE_COUNT
||
2231 PtrToInt(pfi
->next
) != j
++ )
2233 TRACE("error: offset=%ld length=%ld cptable=%d pfi->next=%p j=%d\n",
2234 (long)offset
, (long)length
, pfi
->cptable
, pfi
->next
, j
-1);
2238 if( pfi
->df
.dfPixHeight
== 0 )
2240 TRACE("error: dfPixHeight==0\n");
2244 pfi
->df
.dfFace
= pfr
->lfFaceName
;
2245 if( pfi
->fi_flags
& FI_SCALABLE
)
2247 /* we can pretend we got this font for any resolution */
2248 pfi
->lfd_resolution
= res
;
2249 XFONT_FixupPointSize(pfi
);
2251 pfi
->next
= pfi
+ 1;
2253 if( j
> pfr
->fi_count
) break;
2256 offset
+= sizeof(fontInfo
);
2261 pfr
->next
= (fontResource
*)(pfi
+ 1);
2266 if( pfr
->next
== NULL
&&
2267 *(int*)(pfi
+ 1) == X_FMC_MAGIC
)
2269 /* read LFD stubs */
2270 char* lpch
= (char*)((int*)(pfi
+ 1) + 1);
2271 offset
+= sizeof(int);
2272 for( pfr
= fontList
; pfr
; pfr
= pfr
->next
)
2274 size_t len
= strlen(lpch
) + 1;
2275 TRACE("\t%s, %i instances\n", lpch
, pfr
->fi_count
);
2276 pfr
->resource
= HeapAlloc(GetProcessHeap(),0,sizeof(LFD
));
2277 if (!LFD_Parse(lpch
, pfr
->resource
))
2279 HeapFree( GetProcessHeap(), 0, pfr
->resource
);
2280 pfr
->resource
= NULL
;
2284 if (offset
> length
)
2286 TRACE("error: offset=%ld length=%ld\n",(long)offset
,(long)length
);
2295 TRACE("Wrong length: %ld!=%ld\n",(long)length
,(long)(i
+offset
));
2298 TRACE("Checksum (%x vs. %x) or count (%d vs. %d) mismatch\n",
2299 u
,x_checksum
,i
,x_count
);
2302 HeapFree( GetProcessHeap(), 0, fontList
);
2306 TRACE("fontcache '%s': %s\n", path
, strerror(errno
));
2311 /***********************************************************************
2312 * XFONT_WriteCachedMetrics
2316 static BOOL
XFONT_WriteCachedMetrics( int fd
, unsigned x_checksum
, int x_count
, int n_ff
)
2324 char buffer
[MAX_LFD_LENGTH
];
2326 /* font metrics file:
2330 * +0008 total size to load
2331 * +000C prepackaged font metrics
2334 * +...x + 4 LFD stubs
2337 write( fd
, &x_checksum
, sizeof(unsigned) );
2338 write( fd
, &x_count
, sizeof(int) );
2340 for( j
= i
= 0, pfr
= fontList
; pfr
; pfr
= pfr
->next
)
2342 LFD_UnParse(buffer
, sizeof(buffer
), pfr
->resource
);
2343 i
+= strlen( buffer
) + 1;
2346 i
+= n_ff
* sizeof(fontResource
) + j
* sizeof(fontInfo
) + sizeof(int);
2347 write( fd
, &i
, sizeof(int) );
2349 TRACE("Writing font cache:\n");
2351 for( pfr
= fontList
; pfr
; pfr
= pfr
->next
)
2355 TRACE("\t-%s-%s-, %i instances\n", pfr
->resource
->foundry
, pfr
->resource
->family
, pfr
->fi_count
);
2357 i
= write( fd
, pfr
, sizeof(fontResource
) );
2358 if( i
== sizeof(fontResource
) )
2360 for( k
= 1, pfi
= pfr
->fi
; pfi
; pfi
= pfi
->next
)
2364 fi
.df
.dfFace
= NULL
;
2365 fi
.next
= IntToPtr(k
); /* loader checks this */
2367 j
= write( fd
, &fi
, sizeof(fi
) );
2370 if( j
== sizeof(fontInfo
) ) continue;
2374 if( i
== sizeof(fontResource
) && j
== sizeof(fontInfo
) )
2376 i
= j
= X_FMC_MAGIC
;
2377 write( fd
, &i
, sizeof(int) );
2378 for( pfr
= fontList
; pfr
&& i
== j
; pfr
= pfr
->next
)
2380 LFD_UnParse(buffer
, sizeof(buffer
), pfr
->resource
);
2381 i
= strlen( buffer
) + 1;
2382 j
= write( fd
, buffer
, i
);
2391 /***********************************************************************
2392 * XFONT_GetDefResolution()
2396 * Here we initialize DefResolution which is used in the
2397 * XFONT_Match() penalty function, based on the values of log_pixels
2399 static int XFONT_GetDefResolution( int log_pixels_x
, int log_pixels_y
)
2402 int allowed_xfont_resolutions
[3] = { 72, 75, 100 };
2403 int best
= 0, best_diff
= 65536;
2405 /* FIXME We can only really guess at a best DefResolution
2406 * - this should be configurable
2408 for( i
= best
= 0; i
< num
; i
++ )
2410 j
= abs( log_pixels_x
- allowed_xfont_resolutions
[i
] );
2417 DefResolution
= allowed_xfont_resolutions
[best
];
2418 return DefResolution
;
2422 /***********************************************************************
2425 * Compute the matching score between the logical font and the device font.
2427 * contributions from highest to lowest:
2431 * family flags (only when the facename is not present)
2433 * weight, italics, underlines, strikeouts
2435 * NOTE: you can experiment with different penalty weights to see what happens.
2437 static UINT
XFONT_Match( fontMatch
* pfm
)
2439 fontInfo
* pfi
= pfm
->pfi
; /* device font to match */
2440 LPLOGFONT16 plf
= pfm
->plf
; /* wanted logical font */
2442 BOOL bR6
= pfm
->flags
& FO_MATCH_XYINDEP
; /* from text_caps */
2443 BOOL bScale
= pfi
->fi_flags
& FI_SCALABLE
;
2446 TRACE("\t[ %-2ipt h=%-3i w=%-3i %s%s]\n", pfi
->df
.dfPoints
,
2447 pfi
->df
.dfPixHeight
, pfi
->df
.dfAvgWidth
,
2448 (pfi
->df
.dfWeight
> FW_NORMAL
) ? "Bold " : "Normal ",
2449 (pfi
->df
.dfItalic
) ? "Italic" : "" );
2451 pfm
->flags
&= FO_MATCH_MASK
;
2454 /* pfm->internal_charset: given(required) charset */
2455 /* pfi->internal_charset: charset of this font */
2456 if (pfi
->internal_charset
== DEFAULT_CHARSET
)
2458 /* special case(unicode font) */
2459 /* priority: unmatched charset < unicode < matched charset */
2464 if( pfm
->internal_charset
== DEFAULT_CHARSET
)
2467 if (pfi->internal_charset != ANSI_CHARSET)
2470 if ( pfi
->codepage
!= GetACP() )
2473 else if (pfm
->internal_charset
!= pfi
->internal_charset
)
2475 if ( pfi
->internal_charset
& 0xff00 )
2476 penalty
+= 0x1000; /* internal charset - should not be used */
2485 if( plf
->lfHeight
> 0 )
2487 int h
= pfi
->df
.dfPixHeight
;
2488 d
= h
- plf
->lfHeight
;
2489 height
= plf
->lfHeight
;
2493 int h
= pfi
->df
.dfPixHeight
- pfi
->df
.dfInternalLeading
;
2496 d
= h
+ plf
->lfHeight
;
2497 height
= (-plf
->lfHeight
* pfi
->df
.dfPixHeight
) / h
;
2501 ERR("PixHeight == InternalLeading\n");
2502 penalty
+= 0x1000; /* don't want this */
2508 pfm
->height
= 1; /* Very small */
2512 pfm
->height
= height
;
2513 else if( (plf
->lfQuality
!= PROOF_QUALITY
) && bR6
)
2515 if( d
> 0 ) /* do not shrink raster fonts */
2517 pfm
->height
= pfi
->df
.dfPixHeight
;
2518 penalty
+= (pfi
->df
.dfPixHeight
- height
) * 0x4;
2520 else /* expand only in integer multiples */
2522 pfm
->height
= height
- height
%pfi
->df
.dfPixHeight
;
2523 penalty
+= (height
- pfm
->height
+ 1) * height
/ pfi
->df
.dfPixHeight
;
2526 else /* can't be scaled at all */
2528 if( plf
->lfQuality
!= PROOF_QUALITY
) pfm
->flags
|= FO_SYNTH_HEIGHT
;
2529 pfm
->height
= pfi
->df
.dfPixHeight
;
2530 penalty
+= (d
> 0)? d
* 0x8 : -d
* 0x10;
2534 pfm
->height
= pfi
->df
.dfPixHeight
;
2536 /* Pitch and Family */
2537 if( pfm
->flags
& FO_MATCH_PAF
) {
2538 int family
= plf
->lfPitchAndFamily
& FF_FAMILY
;
2540 /* TMPF_FIXED_PITCH means exactly the opposite */
2541 if( plf
->lfPitchAndFamily
& FIXED_PITCH
) {
2542 if( pfi
->df
.dfPitchAndFamily
& TMPF_FIXED_PITCH
) penalty
+= 0x100;
2543 } else /* Variable is the default */
2544 if( !(pfi
->df
.dfPitchAndFamily
& TMPF_FIXED_PITCH
) ) penalty
+= 0x2;
2546 if (family
!= FF_DONTCARE
&& family
!= (pfi
->df
.dfPitchAndFamily
& FF_FAMILY
) )
2554 if( bR6
|| bScale
) h
= 0;
2557 /* FIXME: not complete */
2559 pfm
->flags
|= FO_SYNTH_WIDTH
;
2560 h
= abs(plf
->lfWidth
- (pfm
->height
* pfi
->df
.dfAvgWidth
)/pfi
->df
.dfPixHeight
);
2562 penalty
+= h
* ( d
) ? 0x2 : 0x1 ;
2564 else if( !(pfi
->fi_flags
& FI_NORMAL
) ) penalty
++;
2567 if( plf
->lfWeight
!= FW_DONTCARE
)
2569 penalty
+= abs(plf
->lfWeight
- pfi
->df
.dfWeight
) / 40;
2570 if( plf
->lfWeight
> pfi
->df
.dfWeight
) pfm
->flags
|= FO_SYNTH_BOLD
;
2571 } else if( pfi
->df
.dfWeight
>= FW_BOLD
) penalty
++; /* choose normal by default */
2574 if( plf
->lfItalic
!= pfi
->df
.dfItalic
)
2577 pfm
->flags
|= FO_SYNTH_ITALIC
;
2580 if( plf
->lfUnderline
) pfm
->flags
|= FO_SYNTH_UNDERLINE
;
2583 if( plf
->lfStrikeOut
) pfm
->flags
|= FO_SYNTH_STRIKEOUT
;
2586 if( penalty
&& !bScale
&& pfi
->lfd_resolution
!= DefResolution
)
2589 TRACE(" returning %i\n", penalty
);
2594 /***********************************************************************
2597 * Scan a particular font resource for the best match.
2599 static UINT
XFONT_MatchFIList( fontMatch
* pfm
)
2601 BOOL skipRaster
= (pfm
->flags
& FO_MATCH_NORASTER
);
2602 UINT current_score
, score
= (UINT
)(-1);
2603 fontMatch fm
= *pfm
;
2605 for( fm
.pfi
= pfm
->pfr
->fi
; fm
.pfi
&& score
; fm
.pfi
= fm
.pfi
->next
)
2607 if( skipRaster
&& !(fm
.pfi
->fi_flags
& FI_SCALABLE
) )
2610 current_score
= XFONT_Match( &fm
);
2611 if( score
> current_score
)
2614 score
= current_score
;
2620 /***********************************************************************
2621 * XFONT_is_ansi_charset
2623 * returns TRUE if the given charset is ANSI_CHARSET.
2625 static BOOL
XFONT_is_ansi_charset( UINT charset
)
2627 return ((charset
== ANSI_CHARSET
) ||
2628 (charset
== DEFAULT_CHARSET
&& GetACP() == 1252));
2631 /***********************************************************************
2632 * XFONT_MatchDeviceFont
2634 * Scan font resource tree.
2637 static void XFONT_MatchDeviceFont( fontResource
* start
, fontMatch
* pfm
)
2639 fontMatch fm
= *pfm
;
2640 UINT current_score
, score
= (UINT
)(-1);
2641 fontResource
** ppfr
;
2643 TRACE("(%u) '%s' h=%i weight=%i %s\n",
2644 pfm
->plf
->lfCharSet
, pfm
->plf
->lfFaceName
, pfm
->plf
->lfHeight
,
2645 pfm
->plf
->lfWeight
, (pfm
->plf
->lfItalic
) ? "Italic" : "" );
2649 /* the following hard-coded font binding assumes 'ANSI_CHARSET'. */
2650 if( !fm
.plf
->lfFaceName
[0] &&
2651 XFONT_is_ansi_charset(fm
.plf
->lfCharSet
) )
2653 switch(fm
.plf
->lfPitchAndFamily
& 0xf0)
2656 strcpy(fm
.plf
->lfFaceName
, "Courier New");
2659 strcpy(fm
.plf
->lfFaceName
, "Times New Roman");
2662 strcpy(fm
.plf
->lfFaceName
, "Arial");
2665 if((fm
.plf
->lfPitchAndFamily
& 0x0f) == FIXED_PITCH
)
2666 strcpy(fm
.plf
->lfFaceName
, "Courier New");
2668 strcpy(fm
.plf
->lfFaceName
, "Arial");
2673 if( fm
.plf
->lfFaceName
[0] )
2675 fm
.pfr
= XFONT_FindFIList( start
, fm
.plf
->lfFaceName
);
2676 if( fm
.pfr
) /* match family */
2678 TRACE("found facename '%s'\n", fm
.pfr
->lfFaceName
);
2680 if( fm
.pfr
->fr_flags
& FR_REMOVED
)
2684 XFONT_MatchFIList( &fm
);
2691 /* get charset if lfFaceName is one of known facenames. */
2693 const struct CharsetBindingInfo
* pcharsetbindings
;
2695 pcharsetbindings
= &charsetbindings
[0];
2696 while ( pcharsetbindings
->pszFaceName
!= NULL
)
2698 if ( !strcmp( pcharsetbindings
->pszFaceName
,
2699 fm
.plf
->lfFaceName
) )
2701 fm
.internal_charset
= pcharsetbindings
->charset
;
2704 pcharsetbindings
++;
2706 TRACE( "%s charset %u\n", fm
.plf
->lfFaceName
, fm
.internal_charset
);
2710 /* match all available fonts */
2712 fm
.flags
|= FO_MATCH_PAF
;
2713 for( ppfr
= &fontList
; *ppfr
&& score
; ppfr
= &(*ppfr
)->next
)
2715 if( (*ppfr
)->fr_flags
& FR_REMOVED
)
2717 if( (*ppfr
)->fo_count
== 0 )
2718 XFONT_RemoveFontResource( ppfr
);
2724 TRACE("%s\n", fm
.pfr
->lfFaceName
);
2726 current_score
= XFONT_MatchFIList( &fm
);
2727 if( current_score
< score
)
2729 score
= current_score
;
2736 /***********************************************************************
2739 static void XFONT_GrowFreeList(int start
, int end
)
2741 /* add all entries from 'start' up to and including 'end' */
2743 memset( fontCache
+ start
, 0, (end
- start
+ 1) * sizeof(fontObject
) );
2745 fontCache
[end
].lru
= fontLF
;
2746 fontCache
[end
].count
= -1;
2748 while( start
< end
)
2750 fontCache
[start
].count
= -1;
2751 fontCache
[start
].lru
= start
+ 1;
2756 static fontObject
* XFONT_LookupCachedFont( const LOGFONT16
*plf
, UINT16
* checksum
)
2758 UINT16 cs
= __lfCheckSum( plf
);
2759 int i
= fontMRU
, prev
= -1;
2764 if( fontCache
[i
].lfchecksum
== cs
&&
2765 !(fontCache
[i
].fo_flags
& FO_REMOVED
) )
2767 /* FIXME: something more intelligent here ? */
2769 if( !memcmp( plf
, &fontCache
[i
].lf
,
2770 sizeof(LOGFONT16
) - LF_FACESIZE
) &&
2771 !strcmp( plf
->lfFaceName
, fontCache
[i
].lf
.lfFaceName
) )
2773 /* remove temporarily from the lru list */
2775 fontCache
[prev
].lru
= fontCache
[i
].lru
;
2777 fontMRU
= (INT16
)fontCache
[i
].lru
;
2778 return (fontCache
+ i
);
2782 i
= (INT16
)fontCache
[i
].lru
;
2787 static fontObject
* XFONT_GetCacheEntry(void)
2793 int prev_i
, prev_j
, j
;
2795 TRACE("font cache is full\n");
2797 /* lookup the least recently used font */
2799 for( prev_i
= prev_j
= j
= -1, i
= fontMRU
; i
>= 0; i
= (INT16
)fontCache
[i
].lru
)
2801 if( fontCache
[i
].count
<= 0 &&
2802 !(fontCache
[i
].fo_flags
& FO_SYSTEM
) )
2810 if( j
>= 0 ) /* unload font */
2812 /* detach from the lru list */
2814 TRACE("\tfreeing entry %i\n", j
);
2816 fontCache
[j
].fr
->fo_count
--;
2819 fontCache
[prev_j
].lru
= fontCache
[j
].lru
;
2820 else fontMRU
= (INT16
)fontCache
[j
].lru
;
2822 /* FIXME: lpXForm, lpPixmap */
2823 HeapFree( GetProcessHeap(), 0, fontCache
[j
].lpX11Trans
);
2826 XFreeFont( gdi_display
, fontCache
[j
].fs
);
2827 wine_tsx11_unlock();
2829 memset( fontCache
+ j
, 0, sizeof(fontObject
) );
2830 return (fontCache
+ j
);
2832 else /* expand cache */
2834 fontObject
* newCache
;
2836 prev_i
= fontCacheSize
+ FONTCACHE
;
2838 TRACE("\tgrowing font cache from %i to %i\n", fontCacheSize
, prev_i
);
2840 if( (newCache
= HeapReAlloc(GetProcessHeap(), 0, fontCache
, prev_i
* sizeof(fontObject
))) )
2843 fontCacheSize
= prev_i
;
2844 fontCache
= newCache
;
2845 XFONT_GrowFreeList( i
, fontCacheSize
- 1);
2851 /* detach from the free list */
2854 fontLF
= (INT16
)fontCache
[i
].lru
;
2855 fontCache
[i
].count
= 0;
2856 return (fontCache
+ i
);
2859 static int XFONT_ReleaseCacheEntry(const fontObject
* pfo
)
2861 UINT u
= (UINT
)(pfo
- fontCache
);
2865 if( u
< fontCacheSize
)
2867 ret
= --fontCache
[u
].count
;
2870 for ( i
= 0; i
< X11FONT_REFOBJS_MAX
; i
++ )
2872 if( CHECK_PFONT(pfo
->prefobjs
[i
]) )
2873 XFONT_ReleaseCacheEntry(__PFONT(pfo
->prefobjs
[i
]));
2883 /***********************************************************************
2884 * X11DRV_FONT_InitX11Metrics
2886 * Initialize font resource list and allocate font cache.
2888 static void X11DRV_FONT_InitX11Metrics( void )
2891 unsigned x_checksum
;
2893 char *buffer
= NULL
;
2896 char fontcheck_name
[] = "-*-*-*-*-normal-*-[12 0 0 12]-*-72-*-*-*-iso8859-1";
2899 x_pattern
= XListFonts(gdi_display
, "*", MAX_FONTS
, &x_count
);
2900 wine_tsx11_unlock();
2902 TRACE("Font Mapper: initializing %i x11 fonts\n", x_count
);
2903 if (x_count
== MAX_FONTS
)
2904 MESSAGE("There may be more fonts available - try increasing the value of MAX_FONTS\n");
2906 for( i
= x_checksum
= 0; i
< x_count
; i
++ )
2910 j
= strlen( x_pattern
[i
] );
2911 if( j
) x_checksum
^= __genericCheckSum( x_pattern
[i
], j
);
2913 x_checksum
|= X_PFONT_MAGIC
;
2915 /* deal with systemwide font metrics cache */
2917 /* @@ Wine registry key: HKCU\Software\Wine\X11 Driver\Fonts */
2918 if (RegOpenKeyA(HKEY_CURRENT_USER
, INIFontSection
, &hkey
) == ERROR_SUCCESS
)
2920 DWORD type
, count
= 0;
2921 if (RegQueryValueExA(hkey
, INIGlobalMetrics
, NULL
, &type
, NULL
, &count
) == ERROR_SUCCESS
&&
2924 buffer
= HeapAlloc(GetProcessHeap(), 0, count
+ 1);
2925 if (RegQueryValueExA(hkey
, INIGlobalMetrics
, NULL
, NULL
, (LPBYTE
)buffer
, &count
) == ERROR_SUCCESS
)
2927 buffer
[count
] = '\0';
2928 TRACE("system fontcache is '%s'\n", buffer
);
2929 XFONT_ReadCachedMetrics(buffer
, DefResolution
, x_checksum
, x_count
);
2931 HeapFree(GetProcessHeap(), 0, buffer
);
2936 if (fontList
== NULL
)
2939 buffer
= XFONT_UserMetricsCache();
2942 TRACE("user fontcache is '%s'\n", buffer
);
2943 XFONT_ReadCachedMetrics(buffer
, DefResolution
, x_checksum
, x_count
);
2947 if (fontList
== NULL
) /* build metrics from scratch */
2949 int n_ff
= XFONT_BuildMetrics(x_pattern
, DefResolution
, x_checksum
, x_count
);
2950 if( buffer
) /* update cached metrics */
2952 int fd
= open( buffer
, O_CREAT
| O_TRUNC
| O_RDWR
, 0666 );
2955 WARN("Unable to create fontcache '%s': %s\n", buffer
, strerror(errno
));
2957 else if( XFONT_WriteCachedMetrics( fd
, x_checksum
, x_count
, n_ff
) == FALSE
)
2959 WARN("Unable to write to fontcache '%s'\n", buffer
);
2960 remove( buffer
); /* couldn't write entire file */
2965 HeapFree(GetProcessHeap(), 0, buffer
);
2968 XFreeFontNames(x_pattern
);
2970 /* check if we're dealing with X11 R6 server */
2971 if( (x_fs
= safe_XLoadQueryFont(gdi_display
, fontcheck_name
)) )
2973 text_caps
|= TC_SF_X_YINDEP
;
2974 XFreeFont(gdi_display
, x_fs
);
2977 wine_tsx11_unlock();
2979 XFONT_WindowsNames();
2980 XFONT_LoadAliases( hkey
);
2981 if (hkey
) XFONT_LoadDefaults( hkey
);
2982 XFONT_LoadIgnores( hkey
);
2984 /* fontList initialization is over, allocate X font cache */
2986 fontCache
= HeapAlloc(GetProcessHeap(), 0, fontCacheSize
* sizeof(fontObject
));
2987 XFONT_GrowFreeList(0, fontCacheSize
- 1);
2990 if (hkey
) RegCloseKey(hkey
);
2993 /***********************************************************************
2996 void X11DRV_FONT_Init( int log_pixels_x
, int log_pixels_y
)
2998 XFONT_GetDefResolution( log_pixels_x
, log_pixels_y
);
3000 if(using_client_side_fonts
)
3001 text_caps
|= TC_VA_ABLE
;
3006 /**********************************************************************
3009 static BOOL
XFONT_SetX11Trans( fontObject
*pfo
)
3016 XGetFontProperty( pfo
->fs
, XA_FONT
, &nameAtom
);
3017 fontName
= XGetAtomName( gdi_display
, nameAtom
);
3018 if (!LFD_Parse(fontName
, &lfd
) || lfd
.pixel_size
[0] != '[')
3021 wine_tsx11_unlock();
3024 #define PX pfo->lpX11Trans
3026 sscanf(lfd
.pixel_size
, "[%f%f%f%f]", &PX
->a
, &PX
->b
, &PX
->c
, &PX
->d
);
3029 XGetFontProperty( pfo
->fs
, x11drv_atom(RAW_ASCENT
), &PX
->RAW_ASCENT
);
3030 XGetFontProperty( pfo
->fs
, x11drv_atom(RAW_DESCENT
), &PX
->RAW_DESCENT
);
3031 wine_tsx11_unlock();
3033 PX
->pixelsize
= hypot(PX
->a
, PX
->b
);
3034 PX
->ascent
= PX
->pixelsize
/ 1000.0 * PX
->RAW_ASCENT
;
3035 PX
->descent
= PX
->pixelsize
/ 1000.0 * PX
->RAW_DESCENT
;
3037 TRACE("[%f %f %f %f] RA = %ld RD = %ld\n",
3038 PX
->a
, PX
->b
, PX
->c
, PX
->d
,
3039 PX
->RAW_ASCENT
, PX
->RAW_DESCENT
);
3045 /***********************************************************************
3046 * X Device Font Objects
3048 static X_PHYSFONT
XFONT_RealizeFont( LPLOGFONT16 plf
,
3049 LPCSTR
* faceMatched
, BOOL bSubFont
,
3050 WORD internal_charset
,
3051 WORD
* pcharsetMatched
)
3057 pfo
= XFONT_LookupCachedFont( plf
, &checksum
);
3068 fm
.internal_charset
= internal_charset
;
3070 if( text_caps
& TC_SF_X_YINDEP
) fm
.flags
= FO_MATCH_XYINDEP
;
3072 /* allocate new font cache entry */
3074 if( (pfo
= XFONT_GetCacheEntry()) )
3076 /* initialize entry and load font */
3077 char lpLFD
[MAX_LFD_LENGTH
];
3078 UINT uRelaxLevel
= 0;
3080 if(abs(plf
->lfHeight
) > MAX_FONT_SIZE
) {
3082 "plf->lfHeight = %d, Creating a 100 pixel font and rescaling metrics\n",
3084 pfo
->rescale
= fabs(plf
->lfHeight
/ 100.0);
3085 if(plf
->lfHeight
> 0) plf
->lfHeight
= 100;
3086 else plf
->lfHeight
= -100;
3090 XFONT_MatchDeviceFont( fontList
, &fm
);
3093 pfo
->fr
->fo_count
++;
3094 pfo
->fo_flags
= fm
.flags
& ~FO_MATCH_MASK
;
3097 pfo
->lfchecksum
= checksum
;
3101 LFD_ComposeLFD( pfo
, fm
.height
, lpLFD
, uRelaxLevel
++ );
3102 if( (pfo
->fs
= safe_XLoadQueryFont( gdi_display
, lpLFD
)) ) break;
3103 } while( uRelaxLevel
);
3106 if(pfo
->lf
.lfEscapement
!= 0) {
3107 pfo
->lpX11Trans
= HeapAlloc(GetProcessHeap(), 0, sizeof(XFONTTRANS
));
3108 if(!XFONT_SetX11Trans( pfo
)) {
3109 HeapFree(GetProcessHeap(), 0, pfo
->lpX11Trans
);
3110 pfo
->lpX11Trans
= NULL
;
3113 XFONT_GetLeading( &pfo
->fi
->df
, pfo
->fs
,
3114 &pfo
->foInternalLeading
, NULL
, pfo
->lpX11Trans
);
3115 pfo
->foAvgCharWidth
= (INT16
)XFONT_GetAvgCharWidth(&pfo
->fi
->df
, pfo
->fs
, pfo
->lpX11Trans
);
3116 pfo
->foMaxCharWidth
= (INT16
)XFONT_GetMaxCharWidth(pfo
->fs
, pfo
->lpX11Trans
);
3118 /* FIXME: If we've got a soft font or
3119 * there are FO_SYNTH_... flags for the
3120 * non PROOF_QUALITY request, the engine
3121 * should rasterize characters into mono
3122 * pixmaps and store them in the pfo->lpPixmap
3123 * array (pfo->fs should be updated as well).
3124 * array (pfo->fs should be updated as well).
3125 * X11DRV_ExtTextOut() must be heavily modified
3126 * to support pixmap blitting and FO_SYNTH_...
3130 pfo
->lpPixmap
= NULL
;
3132 for ( i
= 0; i
< X11FONT_REFOBJS_MAX
; i
++ )
3133 pfo
->prefobjs
[i
] = 0xffffffff; /* invalid value */
3135 /* special treatment for DBCS that needs multiple fonts */
3136 /* All member of pfo must be set correctly. */
3137 if ( bSubFont
== FALSE
)
3140 WORD charsetMatchedSub
;
3142 LPCSTR faceMatchedSub
;
3144 for ( i
= 0; i
< X11FONT_REFOBJS_MAX
; i
++ )
3146 charset_sub
= X11DRV_cptable
[pfo
->fi
->cptable
].
3147 penum_subfont_charset( i
);
3148 if ( charset_sub
== DEFAULT_CHARSET
) break;
3152 lfSub
.lfHeight
=plf
->lfHeight
;
3153 lfSub
.lfCharSet
= (BYTE
)(charset_sub
& 0xff);
3154 lfSub
.lfFaceName
[0] = '\0'; /* FIXME? */
3155 /* this font has sub font */
3156 if ( i
== 0 ) pfo
->prefobjs
[0] = 0;
3158 XFONT_RealizeFont( &lfSub
, &faceMatchedSub
,
3160 &charsetMatchedSub
);
3161 /* FIXME: check charsetMatchedSub */
3166 if( !pfo
) /* couldn't get a new entry, get one of the cached fonts */
3168 UINT current_score
, score
= (UINT
)(-1);
3170 i
= index
= fontMRU
;
3171 fm
.flags
|= FO_MATCH_PAF
;
3174 pfo
= fontCache
+ i
;
3175 fm
.pfr
= pfo
->fr
; fm
.pfi
= pfo
->fi
;
3177 current_score
= XFONT_Match( &fm
);
3178 if( current_score
< score
) index
= i
;
3182 pfo
= fontCache
+ index
;
3187 /* attach at the head of the lru list */
3189 index
= fontMRU
= (pfo
- fontCache
);
3194 TRACE("physfont %i\n", index
);
3195 *faceMatched
= pfo
->fi
->df
.dfFace
;
3196 *pcharsetMatched
= pfo
->fi
->internal_charset
;
3198 return X_PFONT_MAGIC
| index
;
3201 /***********************************************************************
3202 * XFONT_GetFontObject
3204 fontObject
* XFONT_GetFontObject( X_PHYSFONT pFont
)
3206 if( CHECK_PFONT(pFont
) ) return __PFONT(pFont
);
3210 /***********************************************************************
3211 * XFONT_GetFontStruct
3213 XFontStruct
* XFONT_GetFontStruct( X_PHYSFONT pFont
)
3215 if( CHECK_PFONT(pFont
) ) return __PFONT(pFont
)->fs
;
3221 /* X11DRV Interface ****************************************************
3223 * Exposed via the dc->funcs dispatch table. *
3225 ***********************************************************************/
3226 /***********************************************************************
3227 * SelectFont (X11DRV.@)
3229 HFONT CDECL
X11DRV_SelectFont( X11DRV_PDEVICE
*physDev
, HFONT hfont
, HANDLE gdiFont
)
3234 TRACE("hdc=%p, hfont=%p\n", physDev
->hdc
, hfont
);
3236 if (!GetObjectW( hfont
, sizeof(logfont
), &logfont
)) return HGDI_ERROR
;
3238 TRACE("gdiFont = %p\n", gdiFont
);
3240 if(gdiFont
&& using_client_side_fonts
) {
3241 X11DRV_XRender_SelectFont(physDev
, hfont
);
3242 physDev
->has_gdi_font
= TRUE
;
3246 EnterCriticalSection( &crtsc_fonts_X11
);
3248 if(fontList
== NULL
) X11DRV_FONT_InitX11Metrics();
3250 if( CHECK_PFONT(physDev
->font
) )
3251 XFONT_ReleaseCacheEntry( __PFONT(physDev
->font
) );
3253 FONT_LogFontWTo16(&logfont
, &lf
);
3255 /* stock fonts ignore the mapping mode */
3256 if (!is_stock_font( hfont
))
3258 /* Make sure we don't change the sign when converting to device coords */
3259 /* FIXME - check that the other drivers do this correctly */
3262 INT width
= X11DRV_XWStoDS( physDev
, lf
.lfWidth
);
3263 lf
.lfWidth
= (lf
.lfWidth
< 0) ? -abs(width
) : abs(width
);
3264 if (lf
.lfWidth
== 0)
3265 lf
.lfWidth
= 1; /* Minimum width */
3269 INT height
= X11DRV_YWStoDS( physDev
, lf
.lfHeight
);
3270 lf
.lfHeight
= (lf
.lfHeight
< 0) ? -abs(height
) : abs(height
);
3271 if (lf
.lfHeight
== 0)
3272 lf
.lfHeight
= MIN_FONT_SIZE
;
3277 lf
.lfHeight
= -(DEF_POINT_SIZE
* GetDeviceCaps(physDev
->hdc
,LOGPIXELSY
) + (72>>1)) / 72;
3280 /* Fixup aliases before passing to RealizeFont */
3281 /* alias = Windows name in the alias table */
3282 LPCSTR alias
= XFONT_UnAlias( lf
.lfFaceName
);
3284 WORD charsetMatched
;
3286 TRACE("hfont=%p\n", hfont
); /* to connect with the trace from RealizeFont */
3287 physDev
->font
= XFONT_RealizeFont( &lf
, &faceMatched
,
3288 FALSE
, lf
.lfCharSet
,
3291 /* set face to the requested facename if it matched
3292 * so that GetTextFace can get the correct face name
3294 if (alias
&& !strcmp(faceMatched
, lf
.lfFaceName
))
3295 MultiByteToWideChar(CP_ACP
, 0, alias
, -1,
3296 logfont
.lfFaceName
, LF_FACESIZE
);
3298 MultiByteToWideChar(CP_ACP
, 0, faceMatched
, -1,
3299 logfont
.lfFaceName
, LF_FACESIZE
);
3302 * In X, some encodings may have the same lfFaceName.
3304 * -misc-fixed-*-iso8859-1
3305 * -misc-fixed-*-jisx0208.1990-0
3306 * so charset should be saved...
3308 logfont
.lfCharSet
= charsetMatched
;
3311 LeaveCriticalSection( &crtsc_fonts_X11
);
3313 physDev
->has_gdi_font
= FALSE
;
3314 return (HFONT
)1; /* Use a device font */
3318 /***********************************************************************
3320 * X11DRV_EnumDeviceFonts
3322 BOOL CDECL
X11DRV_EnumDeviceFonts( X11DRV_PDEVICE
*physDev
, LPLOGFONTW plf
,
3323 FONTENUMPROCW proc
, LPARAM lp
)
3326 NEWTEXTMETRICEXW tm
;
3327 fontResource
* pfr
= fontList
;
3331 /* don't enumerate x11 fonts if we're using client side fonts */
3332 if (physDev
->has_gdi_font
) return FALSE
;
3336 lfW
.lfCharSet
= DEFAULT_CHARSET
;
3337 lfW
.lfPitchAndFamily
= 0;
3338 lfW
.lfFaceName
[0] = 0;
3342 if( plf
->lfFaceName
[0] )
3344 char facename
[LF_FACESIZE
+1];
3345 WideCharToMultiByte( CP_ACP
, 0, plf
->lfFaceName
, -1,
3346 facename
, sizeof(facename
), NULL
, NULL
);
3347 /* enum all entries in this resource */
3348 pfr
= XFONT_FindFIList( pfr
, facename
);
3352 for( pfi
= pfr
->fi
; pfi
; pfi
= pfi
->next
)
3354 /* Note: XFONT_GetFontMetric() will have to
3355 release the crit section, font list will
3356 have to be retraversed on return */
3357 if(plf
->lfCharSet
== DEFAULT_CHARSET
||
3358 plf
->lfCharSet
== pfi
->df
.dfCharSet
) {
3359 UINT xfm
= XFONT_GetFontMetric( pfi
, &lf
, &tm
);
3361 if( (b
= (*proc
)( &lf
.elfLogFont
, (TEXTMETRICW
*)&tm
, xfm
, lp
)) )
3368 else /* enum first entry in each resource */
3369 for( ; pfr
; pfr
= pfr
->next
)
3373 UINT xfm
= XFONT_GetFontMetric( pfr
->fi
, &lf
, &tm
);
3375 if( (b
= (*proc
)( &lf
.elfLogFont
, (TEXTMETRICW
*)&tm
, xfm
, lp
)) )
3384 /***********************************************************************
3385 * X11DRV_GetTextMetrics
3387 BOOL CDECL
X11DRV_GetTextMetrics(X11DRV_PDEVICE
*physDev
, TEXTMETRICW
*metrics
)
3389 if( CHECK_PFONT(physDev
->font
) )
3391 fontObject
* pfo
= __PFONT(physDev
->font
);
3392 X11DRV_cptable
[pfo
->fi
->cptable
].pGetTextMetricsW( pfo
, metrics
);
3399 /***********************************************************************
3400 * X11DRV_GetCharWidth
3402 BOOL CDECL
X11DRV_GetCharWidth( X11DRV_PDEVICE
*physDev
, UINT firstChar
, UINT lastChar
,
3405 fontObject
* pfo
= XFONT_GetFontObject( physDev
->font
);
3411 if (pfo
->fs
->per_char
== NULL
)
3412 for (i
= firstChar
; i
<= lastChar
; i
++)
3414 *buffer
++ = pfo
->fs
->min_bounds
.attributes
*
3415 pfo
->lpX11Trans
->pixelsize
/ 1000.0 * pfo
->rescale
;
3417 *buffer
++ = pfo
->fs
->min_bounds
.width
* pfo
->rescale
;
3420 XCharStruct
*cs
, *def
;
3421 static XCharStruct __null_char
= { 0, 0, 0, 0, 0, 0 };
3423 CI_GET_CHAR_INFO(pfo
->fs
, pfo
->fs
->default_char
, &__null_char
,
3426 for (i
= firstChar
; i
<= lastChar
; i
++)
3430 UINT ch_f
; /* character code in the font encoding */
3431 WideCharToMultiByte( pfo
->fi
->codepage
, 0, &wch
, 1, (LPSTR
)&ch
, 1, NULL
, NULL
);
3433 if (ch_f
>= pfo
->fs
->min_char_or_byte2
&&
3434 ch_f
<= pfo
->fs
->max_char_or_byte2
)
3436 cs
= &pfo
->fs
->per_char
[(ch_f
- pfo
->fs
->min_char_or_byte2
)];
3437 if (CI_NONEXISTCHAR(cs
)) cs
= def
;
3440 *buffer
++ = max(cs
->attributes
, 0) *
3441 pfo
->lpX11Trans
->pixelsize
/ 1000.0 * pfo
->rescale
;
3443 *buffer
++ = max(cs
->width
, 0 ) * pfo
->rescale
;