?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merged tag ooo/DEV300_m102
[LibreOffice.git] / vcl / win / source / gdi / salgdi3.cxx
blobeded1a8f7aafcde7d083fec761740e3c835c9511
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2000, 2010 Oracle and/or its affiliates.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * This file is part of OpenOffice.org.
10 *
11 * OpenOffice.org is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * OpenOffice.org is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details
19 * (a copy is included in the LICENSE file that accompanied this code).
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * version 3 along with OpenOffice.org. If not, see
23 * <http://www.openoffice.org/license.html>
24 * for a copy of the LGPLv3 License.
25 *
26 ************************************************************************/
27
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_vcl.hxx"
30
31 #include <string.h>
32 #include <malloc.h>
33
34 #include <tools/prewin.h>
35 #include <windows.h>
36 #include <tools/postwin.h>
37 #include <vcl/sysdata.hxx>
38 #include "tools/svwin.h"
39
40 #include "wincomp.hxx"
41 #include "saldata.hxx"
42 #include "salgdi.h"
43
44 #include "vcl/svapp.hxx"
45 #include "vcl/outfont.hxx"
46 #include "vcl/font.hxx"
47 #include "vcl/fontsubset.hxx"
48 #include "vcl/sallayout.hxx"
49
50 #include "vcl/outdev.h" // for ImplGlyphFallbackFontSubstitution
51 #include "unotools/fontcfg.hxx" // for IMPL_FONT_ATTR_SYMBOL
52
53 #include "rtl/logfile.hxx"
54 #include "rtl/tencinfo.h"
55 #include "rtl/textcvt.h"
56 #include "rtl/bootstrap.hxx"
57
58 #include "i18npool/mslangid.hxx"
59
60 #include "osl/module.h"
61 #include "osl/file.hxx"
62 #include "osl/thread.hxx"
63 #include "osl/process.h"
64
65 #include "tools/poly.hxx"
66 #include "tools/debug.hxx"
67 #include "tools/stream.hxx"
68
69 #include "basegfx/polygon/b2dpolygon.hxx"
70 #include "basegfx/polygon/b2dpolypolygon.hxx"
71 #include "basegfx/matrix/b2dhommatrix.hxx"
72 #include <basegfx/matrix/b2dhommatrixtools.hxx>
73
74 #include "sft.hxx"
75
76 #ifdef GCP_KERN_HACK
77 #include <algorithm>
78 #endif
79
80 #ifdef ENABLE_GRAPHITE
81 #include <graphite/GrClient.h>
82 #include <graphite/WinFont.h>
83 #endif
84
85 #include <vector>
86 #include <set>
87 #include <map>
88
89 using namespace vcl;
90
91 static const int MAXFONTHEIGHT = 2048;
92
93 // -----------
94 // - Inlines -
95 // -----------
96
97 inline FIXED FixedFromDouble( double d )
98 {
99 const long l = (long) ( d * 65536. );
100 return *(FIXED*) &l;
101 }
102
103 // -----------------------------------------------------------------------
104
105 inline int IntTimes256FromFixed(FIXED f)
106 {
107 int nFixedTimes256 = (f.value << 8) + ((f.fract+0x80) >> 8);
108 return nFixedTimes256;
109 }
110
111 // =======================================================================
112
113 // these variables can be static because they store system wide settings
114 static bool bImplSalCourierScalable = false;
115 static bool bImplSalCourierNew = false;
116
117
118 // =======================================================================
119
120 // -----------------------------------------------------------------------
121
122 // TODO: also support temporary TTC font files
123 typedef std::map< String, ImplDevFontAttributes > FontAttrMap;
124
125 class ImplFontAttrCache
126 {
127 private:
128 FontAttrMap aFontAttributes;
129 rtl::OUString aCacheFileName;
130 String aBaseURL;
131 sal_Bool bModified;
132
133 protected:
134 String OptimizeURL( const String& rURL ) const;
135
136 enum{ MAGIC = 0x12349876 }; // change if fontattrcache format changes
137
138 public:
139 ImplFontAttrCache( const String& rCacheFileName, const String& rBaseURL );
140 ~ImplFontAttrCache();
141
142 ImplDevFontAttributes GetFontAttr( const String& rFontFileName ) const;
143 void AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& );
144 };
145
146 ImplFontAttrCache::ImplFontAttrCache( const String& rFileNameURL, const String& rBaseURL ) : aBaseURL( rBaseURL )
147 {
148 bModified = FALSE;
149 aBaseURL.ToLowerAscii(); // Windows only, no problem...
150
151 // open the cache file
152 osl::FileBase::getSystemPathFromFileURL( rFileNameURL, aCacheFileName );
153 SvFileStream aCacheFile( aCacheFileName, STREAM_READ );
154 if( !aCacheFile.IsOpen() )
155 return;
156
157 // check the cache version
158 sal_uInt32 nCacheMagic;
159 aCacheFile >> nCacheMagic;
160 if( nCacheMagic != ImplFontAttrCache::MAGIC )
161 return; // ignore cache and rewrite if no match
162
163 // read the cache entries from the file
164 String aFontFileURL, aFontName;
165 ImplDevFontAttributes aDFA;
166 for(;;)
167 {
168 aCacheFile.ReadByteString( aFontFileURL, RTL_TEXTENCODING_UTF8 );
169 if( !aFontFileURL.Len() )
170 break;
171 aCacheFile.ReadByteString( aDFA.maName, RTL_TEXTENCODING_UTF8 );
172
173 short n;
174 aCacheFile >> n; aDFA.meWeight = static_cast<FontWeight>(n);
175 aCacheFile >> n; aDFA.meItalic = static_cast<FontItalic>(n);
176 aCacheFile >> n; aDFA.mePitch = static_cast<FontPitch>(n);
177 aCacheFile >> n; aDFA.meWidthType = static_cast<FontWidth>(n);
178 aCacheFile >> n; aDFA.meFamily = static_cast<FontFamily>(n);
179 aCacheFile >> n; aDFA.mbSymbolFlag = (n != 0);
180
181 aCacheFile.ReadByteStringLine( aDFA.maStyleName, RTL_TEXTENCODING_UTF8 );
182
183 aFontAttributes[ aFontFileURL ] = aDFA;
184 }
185 }
186
187 ImplFontAttrCache::~ImplFontAttrCache()
188 {
189 if ( bModified )
190 {
191 SvFileStream aCacheFile( aCacheFileName, STREAM_WRITE|STREAM_TRUNC );
192 if ( aCacheFile.IsWritable() )
193 {
194 sal_uInt32 nCacheMagic = ImplFontAttrCache::MAGIC;
195 aCacheFile << nCacheMagic;
196
197 // write the cache entries to the file
198 FontAttrMap::const_iterator aIter = aFontAttributes.begin();
199 while ( aIter != aFontAttributes.end() )
200 {
201 const String rFontFileURL( (*aIter).first );
202 const ImplDevFontAttributes& rDFA( (*aIter).second );
203 aCacheFile.WriteByteString( rFontFileURL, RTL_TEXTENCODING_UTF8 );
204 aCacheFile.WriteByteString( rDFA.maName, RTL_TEXTENCODING_UTF8 );
205
206 aCacheFile << static_cast<short>(rDFA.meWeight);
207 aCacheFile << static_cast<short>(rDFA.meItalic);
208 aCacheFile << static_cast<short>(rDFA.mePitch);
209 aCacheFile << static_cast<short>(rDFA.meWidthType);
210 aCacheFile << static_cast<short>(rDFA.meFamily);
211 aCacheFile << static_cast<short>(rDFA.mbSymbolFlag != false);
212
213 aCacheFile.WriteByteStringLine( rDFA.maStyleName, RTL_TEXTENCODING_UTF8 );
214
215 aIter++;
216 }
217 // EOF Marker
218 String aEmptyStr;
219 aCacheFile.WriteByteString( aEmptyStr, RTL_TEXTENCODING_UTF8 );
220 }
221 }
222 }
223
224 String ImplFontAttrCache::OptimizeURL( const String& rURL ) const
225 {
226 String aOptimizedFontFileURL( rURL );
227 aOptimizedFontFileURL.ToLowerAscii(); // Windows only, no problem...
228 if ( aOptimizedFontFileURL.CompareTo( aBaseURL, aBaseURL.Len() ) == COMPARE_EQUAL )
229 aOptimizedFontFileURL = aOptimizedFontFileURL.Copy( aBaseURL.Len() );
230 return aOptimizedFontFileURL;
231 }
232
233 ImplDevFontAttributes ImplFontAttrCache::GetFontAttr( const String& rFontFileName ) const
234 {
235 ImplDevFontAttributes aDFA;
236 FontAttrMap::const_iterator it = aFontAttributes.find( OptimizeURL( rFontFileName ) );
237 if( it != aFontAttributes.end() )
238 {
239 aDFA = it->second;
240 }
241 return aDFA;
242 }
243
244 void ImplFontAttrCache::AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& rDFA )
245 {
246 DBG_ASSERT( rFontFileName.Len() && rDFA.maName.Len(), "ImplFontNameCache::AddFontName - invalid data!" );
247 if ( rFontFileName.Len() && rDFA.maName.Len() )
248 {
249 aFontAttributes.insert( FontAttrMap::value_type( OptimizeURL( rFontFileName ), rDFA ) );
250 bModified = TRUE;
251 }
252 }
253
254 // =======================================================================
255
256 // raw font data with a scoped lifetime
257 class RawFontData
258 {
259 public:
260 explicit RawFontData( HDC, DWORD nTableTag=0 );
261 ~RawFontData() { delete[] mpRawBytes; }
262 const unsigned char* get() const { return mpRawBytes; }
263 const unsigned char* steal() { unsigned char* p = mpRawBytes; mpRawBytes = NULL; return p; }
264 const int size() const { return mnByteCount; }
265
266 private:
267 unsigned char* mpRawBytes;
268 int mnByteCount;
269 };
270
271 RawFontData::RawFontData( HDC hDC, DWORD nTableTag )
272 : mpRawBytes( NULL )
273 , mnByteCount( 0 )
274 {
275 // get required size in bytes
276 mnByteCount = ::GetFontData( hDC, nTableTag, 0, NULL, 0 );
277 if( mnByteCount == GDI_ERROR )
278 return;
279 else if( !mnByteCount )
280 return;
281
282 // allocate the array
283 mpRawBytes = new unsigned char[ mnByteCount ];
284
285 // get raw data in chunks small enough for GetFontData()
286 int nRawDataOfs = 0;
287 DWORD nMaxChunkSize = 0x100000;
288 for(;;)
289 {
290 // calculate remaining raw data to get
291 DWORD nFDGet = mnByteCount - nRawDataOfs;
292 if( nFDGet <= 0 )
293 break;
294 // #i56745# limit GetFontData requests
295 if( nFDGet > nMaxChunkSize )
296 nFDGet = nMaxChunkSize;
297 const DWORD nFDGot = ::GetFontData( hDC, nTableTag, nRawDataOfs,
298 (void*)(mpRawBytes + nRawDataOfs), nFDGet );
299 if( !nFDGot )
300 break;
301 else if( nFDGot != GDI_ERROR )
302 nRawDataOfs += nFDGot;
303 else
304 {
305 // was the chunk too big? reduce it
306 nMaxChunkSize /= 2;
307 if( nMaxChunkSize < 0x10000 )
308 break;
309 }
310 }
311
312 // cleanup if the raw data is incomplete
313 if( nRawDataOfs != mnByteCount )
314 {
315 delete[] mpRawBytes;
316 mpRawBytes = NULL;
317 }
318 }
319
320 // ===========================================================================
321 // platform specific font substitution hooks for glyph fallback enhancement
322 // TODO: move into i18n module (maybe merge with svx/ucsubset.*
323 // or merge with i18nutil/source/utility/unicode_data.h)
324 struct Unicode2LangType
325 {
326 sal_UCS4 mnMinCode;
327 sal_UCS4 mnMaxCode;
328 LanguageType mnLangID;
329 };
330
331 // entries marked with default-CJK get replaced with the default-CJK language
332 #define LANGUAGE_DEFAULT_CJK 0xFFF0
333
334 // map unicode ranges to languages supported by OOo
335 // NOTE: due to the binary search used this list must be sorted by mnMinCode
336 static Unicode2LangType aLangFromCodeChart[]= {
337 {0x0000, 0x007F, LANGUAGE_ENGLISH}, // Basic Latin
338 {0x0080, 0x024F, LANGUAGE_ENGLISH}, // Latin Extended-A and Latin Extended-B
339 {0x0250, 0x02AF, LANGUAGE_SYSTEM}, // IPA Extensions
340 {0x0370, 0x03FF, LANGUAGE_GREEK}, // Greek
341 {0x0590, 0x05FF, LANGUAGE_HEBREW}, // Hebrew
342 {0x0600, 0x06FF, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic
343 {0x0900, 0x097F, LANGUAGE_HINDI}, // Devanagari
344 {0x0980, 0x09FF, LANGUAGE_BENGALI}, // Bengali
345 {0x0A80, 0x0AFF, LANGUAGE_GUJARATI}, // Gujarati
346 {0x0B00, 0x0B7F, LANGUAGE_ORIYA}, // Oriya
347 {0x0B80, 0x0BFF, LANGUAGE_TAMIL}, // Tamil
348 {0x0C00, 0x0C7F, LANGUAGE_TELUGU}, // Telugu
349 {0x0C80, 0x0CFF, LANGUAGE_KANNADA}, // Kannada
350 {0x0D00, 0x0D7F, LANGUAGE_MALAYALAM}, // Malayalam
351 {0x0D80, 0x0D7F, LANGUAGE_SINHALESE_SRI_LANKA}, // Sinhala
352 {0x0E00, 0x0E7F, LANGUAGE_THAI}, // Thai
353 {0x0E80, 0x0EFF, LANGUAGE_LAO}, // Lao
354 {0x0F00, 0x0FFF, LANGUAGE_TIBETAN}, // Tibetan
355 {0x1000, 0x109F, LANGUAGE_BURMESE}, // Burmese
356 {0x10A0, 0x10FF, LANGUAGE_GEORGIAN}, // Georgian
357 {0x1100, 0x11FF, LANGUAGE_KOREAN}, // Hangul Jamo, Korean-specific
358 // {0x1200, 0x139F, LANGUAGE_AMHARIC_ETHIOPIA}, // Ethiopic
359 // {0x1200, 0x139F, LANGUAGE_TIGRIGNA_ETHIOPIA}, // Ethiopic
360 {0x13A0, 0x13FF, LANGUAGE_CHEROKEE_UNITED_STATES}, // Cherokee
361 // {0x1400, 0x167F, LANGUAGE_CANADIAN_ABORIGINAL}, // Canadian Aboriginial Syllabics
362 // {0x1680, 0x169F, LANGUAGE_OGHAM}, // Ogham
363 // {0x16A0, 0x16F0, LANGUAGE_RUNIC}, // Runic
364 // {0x1700, 0x171F, LANGUAGE_TAGALOG}, // Tagalog
365 // {0x1720, 0x173F, LANGUAGE_HANUNOO}, // Hanunoo
366 // {0x1740, 0x175F, LANGUAGE_BUHID}, // Buhid
367 // {0x1760, 0x177F, LANGUAGE_TAGBANWA}, // Tagbanwa
368 {0x1780, 0x17FF, LANGUAGE_KHMER}, // Khmer
369 {0x18A0, 0x18AF, LANGUAGE_MONGOLIAN}, // Mongolian
370 // {0x1900, 0x194F, LANGUAGE_LIMBU}, // Limbu
371 // {0x1950, 0x197F, LANGUAGE_TAILE}, // Tai Le
372 // {0x1980, 0x19DF, LANGUAGE_TAILUE}, // Tai Lue
373 {0x19E0, 0x19FF, LANGUAGE_KHMER}, // Khmer Symbols
374 // {0x1A00, 0x1A1F, LANGUAGE_BUGINESE}, // Buginese/Lontara
375 // {0x1B00, 0x1B7F, LANGUAGE_BALINESE}, // Balinese
376 // {0x1D00, 0x1DFF, LANGUAGE_NONE}, // Phonetic Symbols
377 {0x1E00, 0x1EFF, LANGUAGE_ENGLISH}, // Latin Extended Additional
378 {0x1F00, 0x1FFF, LANGUAGE_GREEK}, // Greek Extended
379 {0x2C60, 0x2C7F, LANGUAGE_ENGLISH}, // Latin Extended-C
380 {0x2E80, 0x2FFf, LANGUAGE_CHINESE_SIMPLIFIED}, // CJK Radicals Supplement + Kangxi Radical + Ideographic Description Characters
381 {0x3000, 0x303F, LANGUAGE_DEFAULT_CJK}, // CJK Symbols and punctuation
382 {0x3040, 0x30FF, LANGUAGE_JAPANESE}, // Japanese Hiragana + Katakana
383 {0x3100, 0x312F, LANGUAGE_CHINESE_TRADITIONAL}, // Bopomofo
384 {0x3130, 0x318F, LANGUAGE_KOREAN}, // Hangul Compatibility Jamo, Kocrean-specific
385 {0x3190, 0x319F, LANGUAGE_JAPANESE}, // Kanbun
386 {0x31A0, 0x31BF, LANGUAGE_CHINESE_TRADITIONAL}, // Bopomofo Extended
387 {0x31C0, 0x31EF, LANGUAGE_DEFAULT_CJK}, // CJK Ideographs
388 {0x31F0, 0x31FF, LANGUAGE_JAPANESE}, // Japanese Katakana Phonetic Extensions
389 {0x3200, 0x321F, LANGUAGE_KOREAN}, // Parenthesized Hangul
390 {0x3220, 0x325F, LANGUAGE_DEFAULT_CJK}, // Parenthesized Ideographs
391 {0x3260, 0x327F, LANGUAGE_KOREAN}, // Circled Hangul
392 {0x3280, 0x32CF, LANGUAGE_DEFAULT_CJK}, // Circled Ideographs
393 {0x32d0, 0x32FF, LANGUAGE_JAPANESE}, // Japanese Circled Katakana
394 {0x3400, 0x4DBF, LANGUAGE_DEFAULT_CJK}, // CJK Unified Ideographs Extension A
395 {0x4E00, 0x9FCF, LANGUAGE_DEFAULT_CJK}, // Unified CJK Ideographs
396 {0xA720, 0xA7FF, LANGUAGE_ENGLISH}, // Latin Extended-D
397 {0xAC00, 0xD7AF, LANGUAGE_KOREAN}, // Hangul Syllables, Korean-specific
398 {0xF900, 0xFAFF, LANGUAGE_DEFAULT_CJK}, // CJK Compatibility Ideographs
399 {0xFB00, 0xFB4F, LANGUAGE_HEBREW}, // Hebrew Presentation Forms
400 {0xFB50, 0xFDFF, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic Presentation Forms-A
401 {0xFE70, 0xFEFE, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic Presentation Forms-B
402 {0xFF65, 0xFF9F, LANGUAGE_JAPANESE}, // Japanese Halfwidth Katakana variant
403 {0xFFA0, 0xFFDC, LANGUAGE_KOREAN}, // Kocrean halfwidth hangual variant
404 {0x10140, 0x1018F, LANGUAGE_GREEK}, // Ancient Greak numbers
405 {0x1D200, 0x1D24F, LANGUAGE_GREEK}, // Ancient Greek Musical
406 {0x20000, 0x2A6DF, LANGUAGE_DEFAULT_CJK}, // CJK Unified Ideographs Extension B
407 {0x2F800, 0x2FA1F, LANGUAGE_DEFAULT_CJK} // CJK Compatibility Ideographs Supplement
408 };
409
410 // get language matching to the missing char
411 LanguageType MapCharToLanguage( sal_UCS4 uChar )
412 {
413 // entries marked with default-CJK get replaced with the prefered CJK language
414 static bool bFirst = true;
415 if( bFirst )
416 {
417 bFirst = false;
418
419 // use method suggested in #i97086# to determnine the systems default language
420 // TODO: move into i18npool or sal/osl/w32/nlsupport.c
421 LanguageType nDefaultLang = 0;
422 HKEY hKey = NULL;
423 LONG lResult = ::RegOpenKeyExA( HKEY_LOCAL_MACHINE,
424 "SYSTEM\\CurrentControlSet\\Control\\Nls\\Language",
425 0, KEY_QUERY_VALUE, &hKey );
426 char aKeyValBuf[16];
427 DWORD nKeyValSize = sizeof(aKeyValBuf);
428 if( ERROR_SUCCESS == lResult )
429 lResult = RegQueryValueExA( hKey, "Default", NULL, NULL, (LPBYTE)aKeyValBuf, &nKeyValSize );
430 aKeyValBuf[ sizeof(aKeyValBuf)-1 ] = '\0';
431 if( ERROR_SUCCESS == lResult )
432 nDefaultLang = (LanguageType)rtl_str_toInt32( aKeyValBuf, 16 );
433
434 // TODO: use the default-CJK language selected in
435 // Tools->Options->LangSettings->Languages when it becomes available here
436 if( !nDefaultLang )
437 nDefaultLang = Application::GetSettings().GetUILanguage();
438
439 LanguageType nDefaultCJK = LANGUAGE_CHINESE;
440 switch( nDefaultLang )
441 {
442 case LANGUAGE_JAPANESE:
443 case LANGUAGE_KOREAN:
444 case LANGUAGE_KOREAN_JOHAB:
445 case LANGUAGE_CHINESE_SIMPLIFIED:
446 case LANGUAGE_CHINESE_TRADITIONAL:
447 case LANGUAGE_CHINESE_SINGAPORE:
448 case LANGUAGE_CHINESE_HONGKONG:
449 case LANGUAGE_CHINESE_MACAU:
450 nDefaultCJK = nDefaultLang;
451 break;
452 default:
453 nDefaultCJK = LANGUAGE_CHINESE;
454 break;
455 }
456
457 // change the marked entries to prefered language
458 static const int nCount = (sizeof(aLangFromCodeChart) / sizeof(*aLangFromCodeChart));
459 for( int i = 0; i < nCount; ++i )
460 {
461 if( aLangFromCodeChart[ i].mnLangID == LANGUAGE_DEFAULT_CJK )
462 aLangFromCodeChart[ i].mnLangID = nDefaultCJK;
463 }
464 }
465
466 // binary search
467 int nLow = 0;
468 int nHigh = (sizeof(aLangFromCodeChart) / sizeof(*aLangFromCodeChart)) - 1;
469 while( nLow <= nHigh )
470 {
471 int nMiddle = (nHigh + nLow) / 2;
472 if( uChar < aLangFromCodeChart[ nMiddle].mnMinCode )
473 nHigh = nMiddle - 1;
474 else if( uChar > aLangFromCodeChart[ nMiddle].mnMaxCode )
475 nLow = nMiddle + 1;
476 else
477 return aLangFromCodeChart[ nMiddle].mnLangID;
478 }
479
480 return LANGUAGE_DONTKNOW;
481 }
482
483 class WinGlyphFallbackSubstititution
484 : public ImplGlyphFallbackFontSubstitution
485 {
486 public:
487 explicit WinGlyphFallbackSubstititution( HDC );
488
489 bool FindFontSubstitute( ImplFontSelectData&, rtl::OUString& rMissingChars ) const;
490 private:
491 HDC mhDC;
492 bool HasMissingChars( const ImplFontData*, const rtl::OUString& rMissingChars ) const;
493 };
494
495 inline WinGlyphFallbackSubstititution::WinGlyphFallbackSubstititution( HDC hDC )
496 : mhDC( hDC )
497 {}
498
499 void ImplGetLogFontFromFontSelect( HDC, const ImplFontSelectData*,
500 LOGFONTW&, bool /*bTestVerticalAvail*/ );
501
502 // does a font face hold the given missing characters?
503 bool WinGlyphFallbackSubstititution::HasMissingChars( const ImplFontData* pFace, const rtl::OUString& rMissingChars ) const
504 {
505 const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFace);
506 const ImplFontCharMap* pCharMap = pWinFont->GetImplFontCharMap();
507 if( !pCharMap )
508 {
509 // construct a Size structure as the parameter of constructor of class ImplFontSelectData
510 const Size aSize( pFace->GetWidth(), pFace->GetHeight() );
511 // create a ImplFontSelectData object for getting s LOGFONT
512 const ImplFontSelectData aFSD( *pFace, aSize, (float)aSize.Height(), 0, false );
513 // construct log font
514 LOGFONTW aLogFont;
515 ImplGetLogFontFromFontSelect( mhDC, &aFSD, aLogFont, true );
516
517 // create HFONT from log font
518 HFONT hNewFont = ::CreateFontIndirectW( &aLogFont );
519 // select the new font into device
520 HFONT hOldFont = ::SelectFont( mhDC, hNewFont );
521
522 // read CMAP table to update their pCharMap
523 pWinFont->UpdateFromHDC( mhDC );;
524
525 // cleanup temporary font
526 ::SelectFont( mhDC, hOldFont );
527 ::DeleteFont( hNewFont );
528
529 // get the new charmap
530 pCharMap = pWinFont->GetImplFontCharMap();
531 }
532
533 // avoid fonts with unknown CMAP subtables for glyph fallback
534 if( !pCharMap || pCharMap->IsDefaultMap() )
535 return false;
536 pCharMap->AddReference();
537
538 int nMatchCount = 0;
539 // static const int nMaxMatchCount = 1; // TODO: tolerate more missing characters?
540 const sal_Int32 nStrLen = rMissingChars.getLength();
541 for( sal_Int32 nStrIdx = 0; nStrIdx < nStrLen; ++nStrIdx )
542 {
543 const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
544 nMatchCount += pCharMap->HasChar( uChar );
545 break; // for now
546 }
547 pCharMap->DeReference();
548
549 const bool bHasMatches = (nMatchCount > 0);
550 return bHasMatches;
551 }
552
553 // find a fallback font for missing characters
554 // TODO: should stylistic matches be searched and prefered?
555 bool WinGlyphFallbackSubstititution::FindFontSubstitute( ImplFontSelectData& rFontSelData, rtl::OUString& rMissingChars ) const
556 {
557 // guess a locale matching to the missing chars
558 com::sun::star::lang::Locale aLocale;
559
560 sal_Int32 nStrIdx = 0;
561 const sal_Int32 nStrLen = rMissingChars.getLength();
562 while( nStrIdx < nStrLen )
563 {
564 const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
565 const LanguageType eLang = MapCharToLanguage( uChar );
566 if( eLang == LANGUAGE_DONTKNOW )
567 continue;
568 MsLangId::convertLanguageToLocale( eLang, aLocale );
569 break;
570 }
571
572 // fall back to default UI locale if the missing characters are inconclusive
573 if( nStrIdx >= nStrLen )
574 aLocale = Application::GetSettings().GetUILocale();
575
576 // first level fallback:
577 // try use the locale specific default fonts defined in VCL.xcu
578 const ImplDevFontList* pDevFontList = ImplGetSVData()->maGDIData.mpScreenFontList;
579 /*const*/ ImplDevFontListData* pDevFont = pDevFontList->ImplFindByLocale( aLocale );
580 if( pDevFont )
581 {
582 const ImplFontData* pFace = pDevFont->FindBestFontFace( rFontSelData );
583 if( HasMissingChars( pFace, rMissingChars ) )
584 {
585 rFontSelData.maSearchName = pDevFont->GetSearchName();
586 return true;
587 }
588 }
589
590 // are the missing characters symbols?
591 pDevFont = pDevFontList->ImplFindByAttributes( IMPL_FONT_ATTR_SYMBOL,
592 rFontSelData.meWeight, rFontSelData.meWidthType,
593 rFontSelData.meFamily, rFontSelData.meItalic, rFontSelData.maSearchName );
594 if( pDevFont )
595 {
596 const ImplFontData* pFace = pDevFont->FindBestFontFace( rFontSelData );
597 if( HasMissingChars( pFace, rMissingChars ) )
598 {
599 rFontSelData.maSearchName = pDevFont->GetSearchName();
600 return true;
601 }
602 }
603
604 // last level fallback, check each font type face one by one
605 const ImplGetDevFontList* pTestFontList = pDevFontList->GetDevFontList();
606 // limit the count of fonts to be checked to prevent hangs
607 static const int MAX_GFBFONT_COUNT = 600;
608 int nTestFontCount = pTestFontList->Count();
609 if( nTestFontCount > MAX_GFBFONT_COUNT )
610 nTestFontCount = MAX_GFBFONT_COUNT;
611
612 for( int i = 0; i < nTestFontCount; ++i )
613 {
614 const ImplFontData* pFace = pTestFontList->Get( i );
615 if( !HasMissingChars( pFace, rMissingChars ) )
616 continue;
617 rFontSelData.maSearchName = pFace->maName;
618 return true;
619 }
620
621 return false;
622 }
623
624 // =======================================================================
625
626 struct ImplEnumInfo
627 {
628 HDC mhDC;
629 ImplDevFontList* mpList;
630 String* mpName;
631 LOGFONTA* mpLogFontA;
632 LOGFONTW* mpLogFontW;
633 UINT mnPreferedCharSet;
634 bool mbCourier;
635 bool mbImplSalCourierScalable;
636 bool mbImplSalCourierNew;
637 bool mbPrinter;
638 int mnFontCount;
639 };
640
641 // =======================================================================
642
643 static CharSet ImplCharSetToSal( BYTE nCharSet )
644 {
645 rtl_TextEncoding eTextEncoding;
646
647 if ( nCharSet == OEM_CHARSET )
648 {
649 UINT nCP = (sal_uInt16)GetOEMCP();
650 switch ( nCP )
651 {
652 // It is unclear why these two (undefined?) code page numbers are
653 // handled specially here:
654 case 1004: eTextEncoding = RTL_TEXTENCODING_MS_1252; break;
655 case 65400: eTextEncoding = RTL_TEXTENCODING_SYMBOL; break;
656 default:
657 eTextEncoding = rtl_getTextEncodingFromWindowsCodePage(nCP);
658 break;
659 };
660 }
661 else
662 {
663 if( nCharSet )
664 eTextEncoding = rtl_getTextEncodingFromWindowsCharset( nCharSet );
665 else
666 eTextEncoding = RTL_TEXTENCODING_UNICODE;
667 }
668
669 return eTextEncoding;
670 }
671
672 // -----------------------------------------------------------------------
673
674 static FontFamily ImplFamilyToSal( BYTE nFamily )
675 {
676 switch ( nFamily & 0xF0 )
677 {
678 case FF_DECORATIVE:
679 return FAMILY_DECORATIVE;
680
681 case FF_MODERN:
682 return FAMILY_MODERN;
683
684 case FF_ROMAN:
685 return FAMILY_ROMAN;
686
687 case FF_SCRIPT:
688 return FAMILY_SCRIPT;
689
690 case FF_SWISS:
691 return FAMILY_SWISS;
692
693 default:
694 break;
695 }
696
697 return FAMILY_DONTKNOW;
698 }
699
700 // -----------------------------------------------------------------------
701
702 static BYTE ImplFamilyToWin( FontFamily eFamily )
703 {
704 switch ( eFamily )
705 {
706 case FAMILY_DECORATIVE:
707 return FF_DECORATIVE;
708
709 case FAMILY_MODERN:
710 return FF_MODERN;
711
712 case FAMILY_ROMAN:
713 return FF_ROMAN;
714
715 case FAMILY_SCRIPT:
716 return FF_SCRIPT;
717
718 case FAMILY_SWISS:
719 return FF_SWISS;
720
721 case FAMILY_SYSTEM:
722 return FF_SWISS;
723
724 default:
725 break;
726 }
727
728 return FF_DONTCARE;
729 }
730
731 // -----------------------------------------------------------------------
732
733 static FontWeight ImplWeightToSal( int nWeight )
734 {
735 if ( nWeight <= FW_THIN )
736 return WEIGHT_THIN;
737 else if ( nWeight <= FW_ULTRALIGHT )
738 return WEIGHT_ULTRALIGHT;
739 else if ( nWeight <= FW_LIGHT )
740 return WEIGHT_LIGHT;
741 else if ( nWeight < FW_MEDIUM )
742 return WEIGHT_NORMAL;
743 else if ( nWeight == FW_MEDIUM )
744 return WEIGHT_MEDIUM;
745 else if ( nWeight <= FW_SEMIBOLD )
746 return WEIGHT_SEMIBOLD;
747 else if ( nWeight <= FW_BOLD )
748 return WEIGHT_BOLD;
749 else if ( nWeight <= FW_ULTRABOLD )
750 return WEIGHT_ULTRABOLD;
751 else
752 return WEIGHT_BLACK;
753 }
754
755 // -----------------------------------------------------------------------
756
757 static int ImplWeightToWin( FontWeight eWeight )
758 {
759 switch ( eWeight )
760 {
761 case WEIGHT_THIN:
762 return FW_THIN;
763
764 case WEIGHT_ULTRALIGHT:
765 return FW_ULTRALIGHT;
766
767 case WEIGHT_LIGHT:
768 return FW_LIGHT;
769
770 case WEIGHT_SEMILIGHT:
771 case WEIGHT_NORMAL:
772 return FW_NORMAL;
773
774 case WEIGHT_MEDIUM:
775 return FW_MEDIUM;
776
777 case WEIGHT_SEMIBOLD:
778 return FW_SEMIBOLD;
779
780 case WEIGHT_BOLD:
781 return FW_BOLD;
782
783 case WEIGHT_ULTRABOLD:
784 return FW_ULTRABOLD;
785
786 case WEIGHT_BLACK:
787 return FW_BLACK;
788
789 default:
790 break;
791 }
792
793 return 0;
794 }
795
796 // -----------------------------------------------------------------------
797
798 inline FontPitch ImplLogPitchToSal( BYTE nPitch )
799 {
800 if ( nPitch & FIXED_PITCH )
801 return PITCH_FIXED;
802 else
803 return PITCH_VARIABLE;
804 }
805
806 // -----------------------------------------------------------------------
807
808 inline FontPitch ImplMetricPitchToSal( BYTE nPitch )
809 {
810 // Sausaecke bei MS !! siehe NT Hilfe
811 if ( !(nPitch & TMPF_FIXED_PITCH) )
812 return PITCH_FIXED;
813 else
814 return PITCH_VARIABLE;
815 }
816
817 // -----------------------------------------------------------------------
818
819 inline BYTE ImplPitchToWin( FontPitch ePitch )
820 {
821 if ( ePitch == PITCH_FIXED )
822 return FIXED_PITCH;
823 else if ( ePitch == PITCH_VARIABLE )
824 return VARIABLE_PITCH;
825 else
826 return DEFAULT_PITCH;
827 }
828
829 // -----------------------------------------------------------------------
830
831 static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXA& rEnumFont,
832 const NEWTEXTMETRICA& rMetric, DWORD nFontType )
833 {
834 ImplDevFontAttributes aDFA;
835
836 const LOGFONTA rLogFont = rEnumFont.elfLogFont;
837
838 // get font face attributes
839 aDFA.meFamily = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
840 aDFA.meWidthType = WIDTH_DONTKNOW;
841 aDFA.meWeight = ImplWeightToSal( rLogFont.lfWeight );
842 aDFA.meItalic = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
843 aDFA.mePitch = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
844 aDFA.mbSymbolFlag = (rLogFont.lfCharSet == SYMBOL_CHARSET);
845
846 // get the font face name
847 aDFA.maName = ImplSalGetUniString( rLogFont.lfFaceName );
848
849 // use the face's style name only if it looks reasonable
850 const char* pStyleName = (const char*)rEnumFont.elfStyle;
851 const char* pEnd = pStyleName + sizeof( rEnumFont.elfStyle );
852 const char* p = pStyleName;
853 for(; *p && (p < pEnd); ++p )
854 if( (0x00 < *p) && (*p < 0x20) )
855 break;
856 if( p < pEnd )
857 aDFA.maStyleName = ImplSalGetUniString( pStyleName );
858
859 // get device specific font attributes
860 aDFA.mbOrientation = (nFontType & RASTER_FONTTYPE) == 0;
861 aDFA.mbDevice = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
862
863 aDFA.mbEmbeddable = false;
864 aDFA.mbSubsettable = false;
865 if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
866 || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
867 aDFA.mbSubsettable = true;
868 else if( 0 != (rMetric.ntmFlags & NTM_TYPE1) ) // TODO: implement subsetting for type1 too
869 aDFA.mbEmbeddable = true;
870
871 // heuristics for font quality
872 // - standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
873 // - subsetting > embedding > none
874 aDFA.mnQuality = 0;
875 if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
876 aDFA.mnQuality += 50;
877 if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
878 aDFA.mnQuality += 10;
879 if( aDFA.mbSubsettable )
880 aDFA.mnQuality += 200;
881 else if( aDFA.mbEmbeddable )
882 aDFA.mnQuality += 100;
883
884 // #i38665# prefer Type1 versions of the standard postscript fonts
885 if( aDFA.mbEmbeddable )
886 {
887 if( aDFA.maName.EqualsAscii( "AvantGarde" )
888 || aDFA.maName.EqualsAscii( "Bookman" )
889 || aDFA.maName.EqualsAscii( "Courier" )
890 || aDFA.maName.EqualsAscii( "Helvetica" )
891 || aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
892 || aDFA.maName.EqualsAscii( "Palatino" )
893 || aDFA.maName.EqualsAscii( "Symbol" )
894 || aDFA.maName.EqualsAscii( "Times" )
895 || aDFA.maName.EqualsAscii( "ZapfChancery" )
896 || aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
897 aDFA.mnQuality += 500;
898 }
899
900 // TODO: add alias names
901 return aDFA;
902 }
903
904 // -----------------------------------------------------------------------
905
906 static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXW& rEnumFont,
907 const NEWTEXTMETRICW& rMetric, DWORD nFontType )
908 {
909 ImplDevFontAttributes aDFA;
910
911 const LOGFONTW rLogFont = rEnumFont.elfLogFont;
912
913 // get font face attributes
914 aDFA.meFamily = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
915 aDFA.meWidthType = WIDTH_DONTKNOW;
916 aDFA.meWeight = ImplWeightToSal( rLogFont.lfWeight );
917 aDFA.meItalic = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
918 aDFA.mePitch = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
919 aDFA.mbSymbolFlag = (rLogFont.lfCharSet == SYMBOL_CHARSET);
920
921 // get the font face name
922 aDFA.maName = reinterpret_cast<const sal_Unicode*>(rLogFont.lfFaceName);
923
924 // use the face's style name only if it looks reasonable
925 const wchar_t* pStyleName = rEnumFont.elfStyle;
926 const wchar_t* pEnd = pStyleName + sizeof(rEnumFont.elfStyle)/sizeof(*rEnumFont.elfStyle);
927 const wchar_t* p = pStyleName;
928 for(; *p && (p < pEnd); ++p )
929 if( *p < 0x0020 )
930 break;
931 if( p < pEnd )
932 aDFA.maStyleName = reinterpret_cast<const sal_Unicode*>(pStyleName);
933
934 // get device specific font attributes
935 aDFA.mbOrientation = (nFontType & RASTER_FONTTYPE) == 0;
936 aDFA.mbDevice = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
937
938 aDFA.mbEmbeddable = false;
939 aDFA.mbSubsettable = false;
940 if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
941 || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
942 aDFA.mbSubsettable = true;
943 else if( 0 != (rMetric.ntmFlags & NTM_TYPE1) ) // TODO: implement subsetting for type1 too
944 aDFA.mbEmbeddable = true;
945
946 // heuristics for font quality
947 // - standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
948 // - subsetting > embedding > none
949 aDFA.mnQuality = 0;
950 if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
951 aDFA.mnQuality += 50;
952 if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
953 aDFA.mnQuality += 10;
954 if( aDFA.mbSubsettable )
955 aDFA.mnQuality += 200;
956 else if( aDFA.mbEmbeddable )
957 aDFA.mnQuality += 100;
958
959 // #i38665# prefer Type1 versions of the standard postscript fonts
960 if( aDFA.mbEmbeddable )
961 {
962 if( aDFA.maName.EqualsAscii( "AvantGarde" )
963 || aDFA.maName.EqualsAscii( "Bookman" )
964 || aDFA.maName.EqualsAscii( "Courier" )
965 || aDFA.maName.EqualsAscii( "Helvetica" )
966 || aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
967 || aDFA.maName.EqualsAscii( "Palatino" )
968 || aDFA.maName.EqualsAscii( "Symbol" )
969 || aDFA.maName.EqualsAscii( "Times" )
970 || aDFA.maName.EqualsAscii( "ZapfChancery" )
971 || aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
972 aDFA.mnQuality += 500;
973 }
974
975 // TODO: add alias names
976 return aDFA;
977 }
978
979 // -----------------------------------------------------------------------
980
981 static ImplWinFontData* ImplLogMetricToDevFontDataA( const ENUMLOGFONTEXA* pLogFont,
982 const NEWTEXTMETRICA* pMetric,
983 DWORD nFontType )
984 {
985 int nHeight = 0;
986 if ( nFontType & RASTER_FONTTYPE )
987 nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
988
989 ImplWinFontData* pData = new ImplWinFontData(
990 WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
991 nHeight,
992 pLogFont->elfLogFont.lfCharSet,
993 pMetric->tmPitchAndFamily );
994
995 return pData;
996 }
997
998 // -----------------------------------------------------------------------
999
1000 static ImplWinFontData* ImplLogMetricToDevFontDataW( const ENUMLOGFONTEXW* pLogFont,
1001 const NEWTEXTMETRICW* pMetric,
1002 DWORD nFontType )
1003 {
1004 int nHeight = 0;
1005 if ( nFontType & RASTER_FONTTYPE )
1006 nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
1007
1008 ImplWinFontData* pData = new ImplWinFontData(
1009 WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
1010 nHeight,
1011 pLogFont->elfLogFont.lfCharSet,
1012 pMetric->tmPitchAndFamily );
1013
1014 return pData;
1015 }
1016
1017 // -----------------------------------------------------------------------
1018
1019 void ImplSalLogFontToFontA( HDC hDC, const LOGFONTA& rLogFont, Font& rFont )
1020 {
1021 String aFontName( ImplSalGetUniString( rLogFont.lfFaceName ) );
1022 if ( aFontName.Len() )
1023 {
1024 rFont.SetName( aFontName );
1025 rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
1026 rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
1027 rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
1028 rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
1029
1030 long nFontHeight = rLogFont.lfHeight;
1031 if ( nFontHeight < 0 )
1032 nFontHeight = -nFontHeight;
1033 long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
1034 if( !nDPIY )
1035 nDPIY = 600;
1036 nFontHeight *= 72;
1037 nFontHeight += nDPIY/2;
1038 nFontHeight /= nDPIY;
1039 rFont.SetSize( Size( 0, nFontHeight ) );
1040 rFont.SetOrientation( (short)rLogFont.lfEscapement );
1041 if ( rLogFont.lfItalic )
1042 rFont.SetItalic( ITALIC_NORMAL );
1043 else
1044 rFont.SetItalic( ITALIC_NONE );
1045 if ( rLogFont.lfUnderline )
1046 rFont.SetUnderline( UNDERLINE_SINGLE );
1047 else
1048 rFont.SetUnderline( UNDERLINE_NONE );
1049 if ( rLogFont.lfStrikeOut )
1050 rFont.SetStrikeout( STRIKEOUT_SINGLE );
1051 else
1052 rFont.SetStrikeout( STRIKEOUT_NONE );
1053 }
1054 }
1055
1056 // -----------------------------------------------------------------------
1057
1058 void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
1059 {
1060 XubString aFontName( reinterpret_cast<const xub_Unicode*>(rLogFont.lfFaceName) );
1061 if ( aFontName.Len() )
1062 {
1063 rFont.SetName( aFontName );
1064 rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
1065 rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
1066 rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
1067 rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
1068
1069 long nFontHeight = rLogFont.lfHeight;
1070 if ( nFontHeight < 0 )
1071 nFontHeight = -nFontHeight;
1072 long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
1073 if( !nDPIY )
1074 nDPIY = 600;
1075 nFontHeight *= 72;
1076 nFontHeight += nDPIY/2;
1077 nFontHeight /= nDPIY;
1078 rFont.SetSize( Size( 0, nFontHeight ) );
1079 rFont.SetOrientation( (short)rLogFont.lfEscapement );
1080 if ( rLogFont.lfItalic )
1081 rFont.SetItalic( ITALIC_NORMAL );
1082 else
1083 rFont.SetItalic( ITALIC_NONE );
1084 if ( rLogFont.lfUnderline )
1085 rFont.SetUnderline( UNDERLINE_SINGLE );
1086 else
1087 rFont.SetUnderline( UNDERLINE_NONE );
1088 if ( rLogFont.lfStrikeOut )
1089 rFont.SetStrikeout( STRIKEOUT_SINGLE );
1090 else
1091 rFont.SetStrikeout( STRIKEOUT_NONE );
1092 }
1093 }
1094
1095 // =======================================================================
1096
1097 ImplWinFontData::ImplWinFontData( const ImplDevFontAttributes& rDFS,
1098 int nHeight, BYTE eWinCharSet, BYTE nPitchAndFamily )
1099 : ImplFontData( rDFS, 0 ),
1100 meWinCharSet( eWinCharSet ),
1101 mnPitchAndFamily( nPitchAndFamily ),
1102 mpFontCharSets( NULL ),
1103 mpUnicodeMap( NULL ),
1104 mbGsubRead( false ),
1105 mbDisableGlyphApi( false ),
1106 mbHasKoreanRange( false ),
1107 mbHasCJKSupport( false ),
1108 #ifdef ENABLE_GRAPHITE
1109 mbHasGraphiteSupport( false ),
1110 #endif
1111 mbHasArabicSupport ( false ),
1112 mbAliasSymbolsLow( false ),
1113 mbAliasSymbolsHigh( false ),
1114 mnId( 0 ),
1115 mpEncodingVector( NULL )
1116 {
1117 SetBitmapSize( 0, nHeight );
1118
1119 if( eWinCharSet == SYMBOL_CHARSET )
1120 {
1121 if( (nPitchAndFamily & TMPF_TRUETYPE) != 0 )
1122 {
1123 // truetype fonts need their symbols as U+F0xx
1124 mbAliasSymbolsHigh = true;
1125 }
1126 else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_DEVICE))
1127 == (TMPF_VECTOR|TMPF_DEVICE) )
1128 {
1129 // scalable device fonts (e.g. builtin printer fonts)
1130 // need their symbols as U+00xx
1131 mbAliasSymbolsLow = true;
1132 }
1133 else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) == 0 )
1134 {
1135 // bitmap fonts need their symbols as U+F0xx
1136 mbAliasSymbolsHigh = true;
1137 }
1138 }
1139 }
1140
1141 // -----------------------------------------------------------------------
1142
1143 ImplWinFontData::~ImplWinFontData()
1144 {
1145 delete[] mpFontCharSets;
1146
1147 if( mpUnicodeMap )
1148 mpUnicodeMap->DeReference();
1149 delete mpEncodingVector;
1150 }
1151
1152 // -----------------------------------------------------------------------
1153
1154 sal_IntPtr ImplWinFontData::GetFontId() const
1155 {
1156 return mnId;
1157 }
1158
1159 // -----------------------------------------------------------------------
1160
1161 void ImplWinFontData::UpdateFromHDC( HDC hDC ) const
1162 {
1163 // short circuit if already initialized
1164 if( mpUnicodeMap != NULL )
1165 return;
1166
1167 ReadCmapTable( hDC );
1168 ReadOs2Table( hDC );
1169 #ifdef ENABLE_GRAPHITE
1170 static const char* pDisableGraphiteText = getenv( "SAL_DISABLE_GRAPHITE" );
1171 if( !pDisableGraphiteText || (pDisableGraphiteText[0] == '0') )
1172 {
1173 mbHasGraphiteSupport = gr::WinFont::FontHasGraphiteTables(hDC);
1174 }
1175 #endif
1176
1177 // even if the font works some fonts have problems with the glyph API
1178 // => the heuristic below tries to figure out which fonts have the problem
1179 TEXTMETRICA aTextMetric;
1180 if( ::GetTextMetricsA( hDC, &aTextMetric ) )
1181 if( !(aTextMetric.tmPitchAndFamily & TMPF_TRUETYPE)
1182 || (aTextMetric.tmPitchAndFamily & TMPF_DEVICE) )
1183 mbDisableGlyphApi = true;
1184
1185 #if 0
1186 // #110548# more important than #107885# => TODO: better solution
1187 DWORD nFLI = GetFontLanguageInfo( hDC );
1188 if( 0 == (nFLI & GCP_GLYPHSHAPE) )
1189 mbDisableGlyphApi = true;
1190 #endif
1191 }
1192
1193 // -----------------------------------------------------------------------
1194
1195 bool ImplWinFontData::HasGSUBstitutions( HDC hDC ) const
1196 {
1197 if( !mbGsubRead )
1198 ReadGsubTable( hDC );
1199 return !maGsubTable.empty();
1200 }
1201
1202 // -----------------------------------------------------------------------
1203
1204 bool ImplWinFontData::IsGSUBstituted( sal_UCS4 cChar ) const
1205 {
1206 return( maGsubTable.find( cChar ) != maGsubTable.end() );
1207 }
1208
1209 // -----------------------------------------------------------------------
1210
1211 const ImplFontCharMap* ImplWinFontData::GetImplFontCharMap() const
1212 {
1213 if( !mpUnicodeMap )
1214 return NULL;
1215 return mpUnicodeMap;
1216 }
1217
1218 // -----------------------------------------------------------------------
1219
1220 static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);}
1221 static unsigned GetUShort( const unsigned char* p ){ return((p[0]<<8)+p[1]);}
1222 //static signed GetSShort( const unsigned char* p ){ return((short)((p[0]<<8)+p[1]));}
1223 static inline DWORD CalcTag( const char p[4]) { return (p[0]+(p[1]<<8)+(p[2]<<16)+(p[3]<<24)); }
1224
1225 void ImplWinFontData::ReadOs2Table( HDC hDC ) const
1226 {
1227 const DWORD Os2Tag = CalcTag( "OS/2" );
1228 DWORD nLength = ::GetFontData( hDC, Os2Tag, 0, NULL, 0 );
1229 if( (nLength == GDI_ERROR) || !nLength )
1230 return;
1231 std::vector<unsigned char> aOS2map( nLength );
1232 unsigned char* pOS2map = &aOS2map[0];
1233 ::GetFontData( hDC, Os2Tag, 0, pOS2map, nLength );
1234 sal_uInt32 nVersion = GetUShort( pOS2map );
1235 if ( nVersion >= 0x0001 && nLength >= 58 )
1236 {
1237 // We need at least version 0x0001 (TrueType rev 1.66)
1238 // to have access to the needed struct members.
1239 sal_uInt32 ulUnicodeRange1 = GetUInt( pOS2map + 42 );
1240 sal_uInt32 ulUnicodeRange2 = GetUInt( pOS2map + 46 );
1241 #if 0
1242 sal_uInt32 ulUnicodeRange3 = GetUInt( pOS2map + 50 );
1243 sal_uInt32 ulUnicodeRange4 = GetUInt( pOS2map + 54 );
1244 #endif
1245
1246 // Check for CJK capabilities of the current font
1247 mbHasCJKSupport = (ulUnicodeRange2 & 0x2DF00000);
1248 mbHasKoreanRange= (ulUnicodeRange1 & 0x10000000)
1249 | (ulUnicodeRange2 & 0x01100000);
1250 mbHasArabicSupport = (ulUnicodeRange1 & 0x00002000);
1251 }
1252 }
1253
1254 // -----------------------------------------------------------------------
1255
1256 void ImplWinFontData::ReadGsubTable( HDC hDC ) const
1257 {
1258 mbGsubRead = true;
1259
1260 // check the existence of a GSUB table
1261 const DWORD GsubTag = CalcTag( "GSUB" );
1262 DWORD nRC = ::GetFontData( hDC, GsubTag, 0, NULL, 0 );
1263 if( (nRC == GDI_ERROR) || !nRC )
1264 return;
1265
1266 // parse the GSUB table through sft
1267 // TODO: parse it directly
1268
1269 // sft needs the full font file data => get it
1270 const RawFontData aRawFontData( hDC );
1271 if( !aRawFontData.get() )
1272 return;
1273
1274 // open font file
1275 sal_uInt32 nFaceNum = 0;
1276 if( !*aRawFontData.get() ) // TTC candidate
1277 nFaceNum = ~0U; // indicate "TTC font extracts only"
1278
1279 TrueTypeFont* pTTFont = NULL;
1280 ::OpenTTFontBuffer( (void*)aRawFontData.get(), aRawFontData.size(), nFaceNum, &pTTFont );
1281 if( !pTTFont )
1282 return;
1283
1284 // add vertically substituted characters to list
1285 static const sal_Unicode aGSUBCandidates[] = {
1286 0x0020, 0x0080, // ASCII
1287 0x2000, 0x2600, // misc
1288 0x3000, 0x3100, // CJK punctutation
1289 0x3300, 0x3400, // squared words
1290 0xFF00, 0xFFF0, // halfwidth|fullwidth forms
1291 0 };
1292
1293 for( const sal_Unicode* pPair = aGSUBCandidates; *pPair; pPair += 2 )
1294 for( sal_Unicode cChar = pPair[0]; cChar < pPair[1]; ++cChar )
1295 if( ::MapChar( pTTFont, cChar, 0 ) != ::MapChar( pTTFont, cChar, 1 ) )
1296 maGsubTable.insert( cChar ); // insert GSUBbed unicodes
1297
1298 CloseTTFont( pTTFont );
1299 }
1300
1301 // -----------------------------------------------------------------------
1302
1303 void ImplWinFontData::ReadCmapTable( HDC hDC ) const
1304 {
1305 if( mpUnicodeMap != NULL )
1306 return;
1307
1308 bool bIsSymbolFont = (meWinCharSet == SYMBOL_CHARSET);
1309 // get the CMAP table from the font which is selected into the DC
1310 const DWORD nCmapTag = CalcTag( "cmap" );
1311 const RawFontData aRawFontData( hDC, nCmapTag );
1312 // parse the CMAP table if available
1313 if( aRawFontData.get() ) {
1314 CmapResult aResult;
1315 ParseCMAP( aRawFontData.get(), aRawFontData.size(), aResult );
1316 mbDisableGlyphApi |= aResult.mbRecoded;
1317 aResult.mbSymbolic = bIsSymbolFont;
1318 if( aResult.mnRangeCount > 0 )
1319 mpUnicodeMap = new ImplFontCharMap( aResult );
1320 }
1321
1322 if( !mpUnicodeMap )
1323 mpUnicodeMap = ImplFontCharMap::GetDefaultMap( bIsSymbolFont );
1324 mpUnicodeMap->AddReference();
1325 }
1326
1327 // =======================================================================
1328
1329 void WinSalGraphics::SetTextColor( SalColor nSalColor )
1330 {
1331 COLORREF aCol = PALETTERGB( SALCOLOR_RED( nSalColor ),
1332 SALCOLOR_GREEN( nSalColor ),
1333 SALCOLOR_BLUE( nSalColor ) );
1334
1335 if( !mbPrinter &&
1336 GetSalData()->mhDitherPal &&
1337 ImplIsSysColorEntry( nSalColor ) )
1338 {
1339 aCol = PALRGB_TO_RGB( aCol );
1340 }
1341
1342 ::SetTextColor( mhDC, aCol );
1343 }
1344
1345 // -----------------------------------------------------------------------
1346
1347 int CALLBACK SalEnumQueryFontProcExW( const ENUMLOGFONTEXW*,
1348 const NEWTEXTMETRICEXW*,
1349 DWORD, LPARAM lParam )
1350 {
1351 *((bool*)(void*)lParam) = true;
1352 return 0;
1353 }
1354
1355 // -----------------------------------------------------------------------
1356
1357 int CALLBACK SalEnumQueryFontProcExA( const ENUMLOGFONTEXA*,
1358 const NEWTEXTMETRICEXA*,
1359 DWORD, LPARAM lParam )
1360 {
1361 *((bool*)(void*)lParam) = true;
1362 return 0;
1363 }
1364
1365 // -----------------------------------------------------------------------
1366
1367 bool ImplIsFontAvailable( HDC hDC, const UniString& rName )
1368 {
1369 // Test, if Font available
1370 LOGFONTW aLogFont;
1371 memset( &aLogFont, 0, sizeof( aLogFont ) );
1372 aLogFont.lfCharSet = DEFAULT_CHARSET;
1373
1374 UINT nNameLen = rName.Len();
1375 if ( nNameLen > (sizeof( aLogFont.lfFaceName )/sizeof( wchar_t ))-1 )
1376 nNameLen = (sizeof( aLogFont.lfFaceName )/sizeof( wchar_t ))-1;
1377 memcpy( aLogFont.lfFaceName, rName.GetBuffer(), nNameLen*sizeof( wchar_t ) );
1378 aLogFont.lfFaceName[nNameLen] = 0;
1379
1380 bool bAvailable = false;
1381 EnumFontFamiliesExW( hDC, &aLogFont, (FONTENUMPROCW)SalEnumQueryFontProcExW,
1382 (LPARAM)(void*)&bAvailable, 0 );
1383
1384 return bAvailable;
1385 }
1386
1387 // -----------------------------------------------------------------------
1388
1389 void ImplGetLogFontFromFontSelect( HDC hDC,
1390 const ImplFontSelectData* pFont,
1391 LOGFONTW& rLogFont,
1392 bool /*bTestVerticalAvail*/ )
1393 {
1394 UniString aName;
1395 if ( pFont->mpFontData )
1396 aName = pFont->mpFontData->maName;
1397 else
1398 aName = pFont->maName.GetToken( 0 );
1399
1400 UINT nNameLen = aName.Len();
1401 if ( nNameLen > (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1 )
1402 nNameLen = (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1;
1403 memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen*sizeof( wchar_t ) );
1404 rLogFont.lfFaceName[nNameLen] = 0;
1405
1406 if( !pFont->mpFontData )
1407 {
1408 rLogFont.lfCharSet = pFont->IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
1409 rLogFont.lfPitchAndFamily = ImplPitchToWin( pFont->mePitch )
1410 | ImplFamilyToWin( pFont->meFamily );
1411 }
1412 else
1413 {
1414 const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>( pFont->mpFontData );
1415 rLogFont.lfCharSet = pWinFontData->GetCharSet();
1416 rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
1417 }
1418
1419 rLogFont.lfWeight = ImplWeightToWin( pFont->meWeight );
1420 rLogFont.lfHeight = (LONG)-pFont->mnHeight;
1421 rLogFont.lfWidth = (LONG)pFont->mnWidth;
1422 rLogFont.lfUnderline = 0;
1423 rLogFont.lfStrikeOut = 0;
1424 rLogFont.lfItalic = (pFont->meItalic) != ITALIC_NONE;
1425 rLogFont.lfEscapement = pFont->mnOrientation;
1426 rLogFont.lfOrientation = rLogFont.lfEscapement;
1427 rLogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1428 rLogFont.lfQuality = DEFAULT_QUALITY;
1429 rLogFont.lfOutPrecision = OUT_TT_PRECIS;
1430 if ( pFont->mnOrientation )
1431 rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
1432
1433 // disable antialiasing if requested
1434 if ( pFont->mbNonAntialiased )
1435 rLogFont.lfQuality = NONANTIALIASED_QUALITY;
1436
1437 // select vertical mode if requested and available
1438 if( pFont->mbVertical && nNameLen )
1439 {
1440 // vertical fonts start with an '@'
1441 memmove( &rLogFont.lfFaceName[1], &rLogFont.lfFaceName[0],
1442 sizeof(rLogFont.lfFaceName)-sizeof(rLogFont.lfFaceName[0]) );
1443 rLogFont.lfFaceName[0] = '@';
1444
1445 // check availability of vertical mode for this font
1446 bool bAvailable = false;
1447 EnumFontFamiliesExW( hDC, &rLogFont, (FONTENUMPROCW)SalEnumQueryFontProcExW,
1448 (LPARAM)&bAvailable, 0 );
1449
1450 if( !bAvailable )
1451 {
1452 // restore non-vertical name if not vertical mode isn't available
1453 memcpy( &rLogFont.lfFaceName[0], aName.GetBuffer(), nNameLen*sizeof(wchar_t) );
1454 if( nNameLen < LF_FACESIZE )
1455 rLogFont.lfFaceName[nNameLen] = '\0';
1456 }
1457 }
1458 }
1459
1460 // -----------------------------------------------------------------------
1461
1462 static void ImplGetLogFontFromFontSelect( HDC hDC,
1463 const ImplFontSelectData* pFont,
1464 LOGFONTA& rLogFont,
1465 bool /*bTestVerticalAvail*/ )
1466 {
1467 ByteString aName;
1468 if( pFont->mpFontData )
1469 aName = ImplSalGetWinAnsiString( pFont->mpFontData->maName );
1470 else
1471 aName = ImplSalGetWinAnsiString( pFont->maName.GetToken( 0 ) );
1472
1473 int nNameLen = aName.Len();
1474 if( nNameLen > LF_FACESIZE )
1475 nNameLen = LF_FACESIZE;
1476 memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen );
1477 if( nNameLen < LF_FACESIZE )
1478 rLogFont.lfFaceName[nNameLen] = '\0';
1479
1480 if( !pFont->mpFontData )
1481 {
1482 rLogFont.lfCharSet = pFont->IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
1483 rLogFont.lfPitchAndFamily = ImplPitchToWin( pFont->mePitch )
1484 | ImplFamilyToWin( pFont->meFamily );
1485 }
1486 else
1487 {
1488 const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>( pFont->mpFontData );
1489 rLogFont.lfCharSet = pWinFontData->GetCharSet();
1490 rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
1491 }
1492
1493 rLogFont.lfWeight = ImplWeightToWin( pFont->meWeight );
1494 rLogFont.lfHeight = (LONG)-pFont->mnHeight;
1495 rLogFont.lfWidth = (LONG)pFont->mnWidth;
1496 rLogFont.lfUnderline = 0;
1497 rLogFont.lfStrikeOut = 0;
1498 rLogFont.lfItalic = (pFont->meItalic) != ITALIC_NONE;
1499 rLogFont.lfEscapement = pFont->mnOrientation;
1500 rLogFont.lfOrientation = rLogFont.lfEscapement; // ignored by W98
1501 rLogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1502 rLogFont.lfQuality = DEFAULT_QUALITY;
1503 rLogFont.lfOutPrecision = OUT_TT_PRECIS;
1504 if( pFont->mnOrientation )
1505 rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
1506
1507 // disable antialiasing if requested
1508 if( pFont->mbNonAntialiased )
1509 rLogFont.lfQuality = NONANTIALIASED_QUALITY;
1510
1511 // select vertical mode if requested and available
1512 if( pFont->mbVertical && nNameLen )
1513 {
1514 // vertical fonts start with an '@'
1515 memmove( &rLogFont.lfFaceName[1], &rLogFont.lfFaceName[0],
1516 sizeof(rLogFont.lfFaceName)-sizeof(rLogFont.lfFaceName[0]) );
1517 rLogFont.lfFaceName[0] = '@';
1518
1519 // check availability of vertical mode for this font
1520 bool bAvailable = false;
1521 EnumFontFamiliesExA( hDC, &rLogFont, (FONTENUMPROCA)SalEnumQueryFontProcExA,
1522 (LPARAM)&bAvailable, 0 );
1523
1524 if( !bAvailable )
1525 {
1526 // restore non-vertical name if vertical mode is not supported
1527 memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen );
1528 if( nNameLen < LF_FACESIZE )
1529 rLogFont.lfFaceName[nNameLen] = '\0';
1530 }
1531 }
1532 }
1533
1534 // -----------------------------------------------------------------------
1535
1536 HFONT WinSalGraphics::ImplDoSetFont( ImplFontSelectData* i_pFont, float& o_rFontScale, HFONT& o_rOldFont )
1537 {
1538 HFONT hNewFont = 0;
1539
1540 HDC hdcScreen = 0;
1541 if( mbVirDev )
1542 // only required for virtual devices, see below for details
1543 hdcScreen = GetDC(0);
1544
1545 if( true/*aSalShlData.mbWNT*/ )
1546 {
1547 LOGFONTW aLogFont;
1548 ImplGetLogFontFromFontSelect( mhDC, i_pFont, aLogFont, true );
1549
1550 // on the display we prefer Courier New when Courier is a
1551 // bitmap only font and we need to stretch or rotate it
1552 if( mbScreen
1553 && (i_pFont->mnWidth != 0
1554 || i_pFont->mnOrientation != 0
1555 || i_pFont->mpFontData == NULL
1556 || (i_pFont->mpFontData->GetHeight() != i_pFont->mnHeight))
1557 && !bImplSalCourierScalable
1558 && bImplSalCourierNew
1559 && (ImplSalWICompareAscii( aLogFont.lfFaceName, "Courier" ) == 0) )
1560 lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
1561
1562 // #i47675# limit font requests to MAXFONTHEIGHT
1563 // TODO: share MAXFONTHEIGHT font instance
1564 if( (-aLogFont.lfHeight <= MAXFONTHEIGHT)
1565 && (+aLogFont.lfWidth <= MAXFONTHEIGHT) )
1566 {
1567 o_rFontScale = 1.0;
1568 }
1569 else if( -aLogFont.lfHeight >= +aLogFont.lfWidth )
1570 {
1571 o_rFontScale = -aLogFont.lfHeight / (float)MAXFONTHEIGHT;
1572 aLogFont.lfHeight = -MAXFONTHEIGHT;
1573 aLogFont.lfWidth = FRound( aLogFont.lfWidth / o_rFontScale );
1574 }
1575 else // #i95867# also limit font widths
1576 {
1577 o_rFontScale = +aLogFont.lfWidth / (float)MAXFONTHEIGHT;
1578 aLogFont.lfWidth = +MAXFONTHEIGHT;
1579 aLogFont.lfHeight = FRound( aLogFont.lfHeight / o_rFontScale );
1580 }
1581
1582 hNewFont = ::CreateFontIndirectW( &aLogFont );
1583 if( hdcScreen )
1584 {
1585 // select font into screen hdc first to get an antialiased font
1586 // see knowledge base article 305290:
1587 // "PRB: Fonts Not Drawn Antialiased on Device Context for DirectDraw Surface"
1588 SelectFont( hdcScreen, SelectFont( hdcScreen , hNewFont ) );
1589 }
1590 o_rOldFont = ::SelectFont( mhDC, hNewFont );
1591
1592 TEXTMETRICW aTextMetricW;
1593 if( !::GetTextMetricsW( mhDC, &aTextMetricW ) )
1594 {
1595 // the selected font doesn't work => try a replacement
1596 // TODO: use its font fallback instead
1597 lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
1598 aLogFont.lfPitchAndFamily = FIXED_PITCH;
1599 HFONT hNewFont2 = CreateFontIndirectW( &aLogFont );
1600 SelectFont( mhDC, hNewFont2 );
1601 DeleteFont( hNewFont );
1602 hNewFont = hNewFont2;
1603 }
1604 }
1605
1606 if( hdcScreen )
1607 ::ReleaseDC( NULL, hdcScreen );
1608
1609 return hNewFont;
1610 }
1611
1612 sal_uInt16 WinSalGraphics::SetFont( ImplFontSelectData* pFont, int nFallbackLevel )
1613 {
1614 // return early if there is no new font
1615 if( !pFont )
1616 {
1617 // deselect still active font
1618 if( mhDefFont )
1619 ::SelectFont( mhDC, mhDefFont );
1620 // release no longer referenced font handles
1621 for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
1622 {
1623 if( mhFonts[i] )
1624 ::DeleteFont( mhFonts[i] );
1625 mhFonts[ i ] = 0;
1626 }
1627 mhDefFont = 0;
1628 return 0;
1629 }
1630
1631 DBG_ASSERT( pFont->mpFontData, "WinSalGraphics mpFontData==NULL");
1632 mpWinFontEntry[ nFallbackLevel ] = reinterpret_cast<ImplWinFontEntry*>( pFont->mpFontEntry );
1633 mpWinFontData[ nFallbackLevel ] = static_cast<const ImplWinFontData*>( pFont->mpFontData );
1634
1635 HFONT hOldFont = 0;
1636 HFONT hNewFont = ImplDoSetFont( pFont, mfFontScale, hOldFont );
1637
1638 if( !mhDefFont )
1639 {
1640 // keep default font
1641 mhDefFont = hOldFont;
1642 }
1643 else
1644 {
1645 // release no longer referenced font handles
1646 for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
1647 {
1648 if( mhFonts[i] )
1649 {
1650 ::DeleteFont( mhFonts[i] );
1651 mhFonts[i] = 0;
1652 }
1653 }
1654 }
1655
1656 // store new font in correct layer
1657 mhFonts[ nFallbackLevel ] = hNewFont;
1658 // now the font is live => update font face
1659 if( mpWinFontData[ nFallbackLevel ] )
1660 mpWinFontData[ nFallbackLevel ]->UpdateFromHDC( mhDC );
1661
1662 if( !nFallbackLevel )
1663 {
1664 mbFontKernInit = TRUE;
1665 if ( mpFontKernPairs )
1666 {
1667 delete[] mpFontKernPairs;
1668 mpFontKernPairs = NULL;
1669 }
1670 mnFontKernPairCount = 0;
1671 }
1672
1673 mnFontCharSetCount = 0;
1674
1675 // some printers have higher internal resolution, so their
1676 // text output would be different from what we calculated
1677 // => suggest DrawTextArray to workaround this problem
1678 if ( mbPrinter )
1679 return SAL_SETFONT_USEDRAWTEXTARRAY;
1680 else
1681 return 0;
1682 }
1683
1684 // -----------------------------------------------------------------------
1685
1686 void WinSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
1687 {
1688 // temporarily change the HDC to the font in the fallback level
1689 HFONT hOldFont = SelectFont( mhDC, mhFonts[nFallbackLevel] );
1690
1691 wchar_t aFaceName[LF_FACESIZE+60];
1692 if( ::GetTextFaceW( mhDC, sizeof(aFaceName)/sizeof(wchar_t), aFaceName ) )
1693 pMetric->maName = reinterpret_cast<const sal_Unicode*>(aFaceName);
1694
1695 // get the font metric
1696 TEXTMETRICA aWinMetric;
1697 const bool bOK = GetTextMetricsA( mhDC, &aWinMetric );
1698 // restore the HDC to the font in the base level
1699 SelectFont( mhDC, hOldFont );
1700 if( !bOK )
1701 return;
1702
1703 // device independent font attributes
1704 pMetric->meFamily = ImplFamilyToSal( aWinMetric.tmPitchAndFamily );;
1705 pMetric->mbSymbolFlag = (aWinMetric.tmCharSet == SYMBOL_CHARSET);
1706 pMetric->meWeight = ImplWeightToSal( aWinMetric.tmWeight );
1707 pMetric->mePitch = ImplMetricPitchToSal( aWinMetric.tmPitchAndFamily );
1708 pMetric->meItalic = aWinMetric.tmItalic ? ITALIC_NORMAL : ITALIC_NONE;
1709 pMetric->mnSlant = 0;
1710
1711 // device dependend font attributes
1712 pMetric->mbDevice = (aWinMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
1713 pMetric->mbScalableFont = (aWinMetric.tmPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) != 0;
1714 if( pMetric->mbScalableFont )
1715 {
1716 // check if there are kern pairs
1717 // TODO: does this work with GPOS kerning?
1718 DWORD nKernPairs = ::GetKerningPairsA( mhDC, 0, NULL );
1719 pMetric->mbKernableFont = (nKernPairs > 0);
1720 }
1721 else
1722 {
1723 // bitmap fonts cannot be rotated directly
1724 pMetric->mnOrientation = 0;
1725 // bitmap fonts have no kerning
1726 pMetric->mbKernableFont = false;
1727 }
1728
1729 // transformation dependend font metrics
1730 pMetric->mnWidth = static_cast<int>( mfFontScale * aWinMetric.tmAveCharWidth );
1731 pMetric->mnIntLeading = static_cast<int>( mfFontScale * aWinMetric.tmInternalLeading );
1732 pMetric->mnExtLeading = static_cast<int>( mfFontScale * aWinMetric.tmExternalLeading );
1733 pMetric->mnAscent = static_cast<int>( mfFontScale * aWinMetric.tmAscent );
1734 pMetric->mnDescent = static_cast<int>( mfFontScale * aWinMetric.tmDescent );
1735
1736 // #107888# improved metric compatibility for Asian fonts...
1737 // TODO: assess workaround below for CWS >= extleading
1738 // TODO: evaluate use of aWinMetric.sTypo* members for CJK
1739 if( mpWinFontData[nFallbackLevel] && mpWinFontData[nFallbackLevel]->SupportsCJK() )
1740 {
1741 pMetric->mnIntLeading += pMetric->mnExtLeading;
1742
1743 // #109280# The line height for Asian fonts is too small.
1744 // Therefore we add half of the external leading to the
1745 // ascent, the other half is added to the descent.
1746 const long nHalfTmpExtLeading = pMetric->mnExtLeading / 2;
1747 const long nOtherHalfTmpExtLeading = pMetric->mnExtLeading - nHalfTmpExtLeading;
1748
1749 // #110641# external leading for Asian fonts.
1750 // The factor 0.3 has been confirmed with experiments.
1751 long nCJKExtLeading = static_cast<long>(0.30 * (pMetric->mnAscent + pMetric->mnDescent));
1752 nCJKExtLeading -= pMetric->mnExtLeading;
1753 pMetric->mnExtLeading = (nCJKExtLeading > 0) ? nCJKExtLeading : 0;
1754
1755 pMetric->mnAscent += nHalfTmpExtLeading;
1756 pMetric->mnDescent += nOtherHalfTmpExtLeading;
1757 }
1758
1759 pMetric->mnMinKashida = GetMinKashidaWidth();
1760 }
1761
1762 // -----------------------------------------------------------------------
1763
1764 int CALLBACK SalEnumCharSetsProcExA( const ENUMLOGFONTEXA* pLogFont,
1765 const NEWTEXTMETRICEXA* /*pMetric*/,
1766 DWORD /*nFontType*/, LPARAM lParam )
1767 {
1768 WinSalGraphics* pData = (WinSalGraphics*)lParam;
1769 // Charset already in the list?
1770 for ( BYTE i = 0; i < pData->mnFontCharSetCount; i++ )
1771 {
1772 if ( pData->mpFontCharSets[i] == pLogFont->elfLogFont.lfCharSet )
1773 return 1;
1774 }
1775 pData->mpFontCharSets[pData->mnFontCharSetCount] = pLogFont->elfLogFont.lfCharSet;
1776 pData->mnFontCharSetCount++;
1777 return 1;
1778 }
1779
1780 // -----------------------------------------------------------------------
1781
1782 static void ImplGetAllFontCharSets( WinSalGraphics* pData )
1783 {
1784 if ( !pData->mpFontCharSets )
1785 pData->mpFontCharSets = new BYTE[256];
1786
1787 LOGFONTA aLogFont;
1788 memset( &aLogFont, 0, sizeof( aLogFont ) );
1789 aLogFont.lfCharSet = DEFAULT_CHARSET;
1790 GetTextFaceA( pData->mhDC, sizeof( aLogFont.lfFaceName ), aLogFont.lfFaceName );
1791 EnumFontFamiliesExA( pData->mhDC, &aLogFont, (FONTENUMPROCA)SalEnumCharSetsProcExA,
1792 (LPARAM)(void*)pData, 0 );
1793 }
1794
1795 // -----------------------------------------------------------------------
1796
1797 static void ImplAddKerningPairs( WinSalGraphics* pData )
1798 {
1799 sal_uLong nPairs = ::GetKerningPairsA( pData->mhDC, 0, NULL );
1800 if ( !nPairs )
1801 return;
1802
1803 CHARSETINFO aInfo;
1804 if ( !TranslateCharsetInfo( (DWORD*)(sal_uLong)GetTextCharset( pData->mhDC ), &aInfo, TCI_SRCCHARSET ) )
1805 return;
1806
1807 if ( !pData->mpFontKernPairs )
1808 pData->mpFontKernPairs = new KERNINGPAIR[nPairs];
1809 else
1810 {
1811 KERNINGPAIR* pOldPairs = pData->mpFontKernPairs;
1812 pData->mpFontKernPairs = new KERNINGPAIR[nPairs+pData->mnFontKernPairCount];
1813 memcpy( pData->mpFontKernPairs, pOldPairs,
1814 pData->mnFontKernPairCount*sizeof( KERNINGPAIR ) );
1815 delete[] pOldPairs;
1816 }
1817
1818 UINT nCP = aInfo.ciACP;
1819 sal_uLong nOldPairs = pData->mnFontKernPairCount;
1820 KERNINGPAIR* pTempPair = pData->mpFontKernPairs+pData->mnFontKernPairCount;
1821 nPairs = ::GetKerningPairsA( pData->mhDC, nPairs, pTempPair );
1822 for ( sal_uLong i = 0; i < nPairs; i++ )
1823 {
1824 unsigned char aBuf[2];
1825 wchar_t nChar;
1826 int nLen;
1827 sal_Bool bAdd = TRUE;
1828
1829 // None-ASCII?, then we must convert the char
1830 if ( (pTempPair->wFirst > 125) || (pTempPair->wFirst == 92) )
1831 {
1832 if ( pTempPair->wFirst < 256 )
1833 {
1834 aBuf[0] = (unsigned char)pTempPair->wFirst;
1835 nLen = 1;
1836 }
1837 else
1838 {
1839 aBuf[0] = (unsigned char)(pTempPair->wFirst >> 8);
1840 aBuf[1] = (unsigned char)(pTempPair->wFirst & 0xFF);
1841 nLen = 2;
1842 }
1843 if ( MultiByteToWideChar( nCP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
1844 (const char*)aBuf, nLen, &nChar, 1 ) )
1845 pTempPair->wFirst = nChar;
1846 else
1847 bAdd = FALSE;
1848 }
1849 if ( (pTempPair->wSecond > 125) || (pTempPair->wSecond == 92) )
1850 {
1851 if ( pTempPair->wSecond < 256 )
1852 {
1853 aBuf[0] = (unsigned char)pTempPair->wSecond;
1854 nLen = 1;
1855 }
1856 else
1857 {
1858 aBuf[0] = (unsigned char)(pTempPair->wSecond >> 8);
1859 aBuf[1] = (unsigned char)(pTempPair->wSecond & 0xFF);
1860 nLen = 2;
1861 }
1862 if ( MultiByteToWideChar( nCP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
1863 (const char*)aBuf, nLen, &nChar, 1 ) )
1864 pTempPair->wSecond = nChar;
1865 else
1866 bAdd = FALSE;
1867 }
1868
1869 // TODO: get rid of linear search!
1870 KERNINGPAIR* pTempPair2 = pData->mpFontKernPairs;
1871 for ( sal_uLong j = 0; j < nOldPairs; j++ )
1872 {
1873 if ( (pTempPair2->wFirst == pTempPair->wFirst) &&
1874 (pTempPair2->wSecond == pTempPair->wSecond) )
1875 {
1876 bAdd = FALSE;
1877 break;
1878 }
1879 pTempPair2++;
1880 }
1881
1882 if ( bAdd )
1883 {
1884 KERNINGPAIR* pDestPair = pData->mpFontKernPairs+pData->mnFontKernPairCount;
1885 if ( pDestPair != pTempPair )
1886 memcpy( pDestPair, pTempPair, sizeof( KERNINGPAIR ) );
1887 pData->mnFontKernPairCount++;
1888 }
1889
1890 pTempPair++;
1891 }
1892 }
1893
1894 // -----------------------------------------------------------------------
1895
1896 sal_uLong WinSalGraphics::GetKernPairs( sal_uLong nPairs, ImplKernPairData* pKernPairs )
1897 {
1898 DBG_ASSERT( sizeof( KERNINGPAIR ) == sizeof( ImplKernPairData ),
1899 "WinSalGraphics::GetKernPairs(): KERNINGPAIR != ImplKernPairData" );
1900
1901 if ( mbFontKernInit )
1902 {
1903 if( mpFontKernPairs )
1904 {
1905 delete[] mpFontKernPairs;
1906 mpFontKernPairs = NULL;
1907 }
1908 mnFontKernPairCount = 0;
1909
1910 KERNINGPAIR* pPairs = NULL;
1911 int nCount = ::GetKerningPairsW( mhDC, 0, NULL );
1912 if( nCount )
1913 {
1914 #ifdef GCP_KERN_HACK
1915 pPairs = new KERNINGPAIR[ nCount+1 ];
1916 mpFontKernPairs = pPairs;
1917 mnFontKernPairCount = nCount;
1918 ::GetKerningPairsW( mhDC, nCount, pPairs );
1919 #else // GCP_KERN_HACK
1920 pPairs = pKernPairs;
1921 nCount = (nCount < nPairs) : nCount : nPairs;
1922 ::GetKerningPairsW( mhDC, nCount, pPairs );
1923 return nCount;
1924 #endif // GCP_KERN_HACK
1925 }
1926
1927 mbFontKernInit = FALSE;
1928
1929 std::sort( mpFontKernPairs, mpFontKernPairs + mnFontKernPairCount, ImplCmpKernData );
1930 }
1931
1932 if( !pKernPairs )
1933 return mnFontKernPairCount;
1934 else if( mpFontKernPairs )
1935 {
1936 if ( nPairs < mnFontKernPairCount )
1937 nPairs = mnFontKernPairCount;
1938 memcpy( pKernPairs, mpFontKernPairs,
1939 nPairs*sizeof( ImplKernPairData ) );
1940 return nPairs;
1941 }
1942
1943 return 0;
1944 }
1945
1946 // -----------------------------------------------------------------------
1947
1948 const ImplFontCharMap* WinSalGraphics::GetImplFontCharMap() const
1949 {
1950 if( !mpWinFontData[0] )
1951 return ImplFontCharMap::GetDefaultMap();
1952 return mpWinFontData[0]->GetImplFontCharMap();
1953 }
1954
1955 // -----------------------------------------------------------------------
1956
1957 int CALLBACK SalEnumFontsProcExA( const ENUMLOGFONTEXA* pLogFont,
1958 const NEWTEXTMETRICEXA* pMetric,
1959 DWORD nFontType, LPARAM lParam )
1960 {
1961 ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
1962 if ( !pInfo->mpName )
1963 {
1964 // Ignore vertical fonts
1965 if ( pLogFont->elfLogFont.lfFaceName[0] != '@' )
1966 {
1967 if ( !pInfo->mbImplSalCourierNew )
1968 pInfo->mbImplSalCourierNew = stricmp( pLogFont->elfLogFont.lfFaceName, "Courier New" ) == 0;
1969 if ( !pInfo->mbImplSalCourierScalable )
1970 pInfo->mbCourier = stricmp( pLogFont->elfLogFont.lfFaceName, "Courier" ) == 0;
1971 else
1972 pInfo->mbCourier = FALSE;
1973 String aName( ImplSalGetUniString( pLogFont->elfLogFont.lfFaceName ) );
1974 pInfo->mpName = &aName;
1975 strncpy( pInfo->mpLogFontA->lfFaceName, pLogFont->elfLogFont.lfFaceName, LF_FACESIZE );
1976 pInfo->mpLogFontA->lfCharSet = pLogFont->elfLogFont.lfCharSet;
1977 EnumFontFamiliesExA( pInfo->mhDC, pInfo->mpLogFontA, (FONTENUMPROCA)SalEnumFontsProcExA,
1978 (LPARAM)(void*)pInfo, 0 );
1979 pInfo->mpLogFontA->lfFaceName[0] = '\0';
1980 pInfo->mpLogFontA->lfCharSet = DEFAULT_CHARSET;
1981 pInfo->mpName = NULL;
1982 pInfo->mbCourier = FALSE;
1983 }
1984 }
1985 else
1986 {
1987 // ignore non-scalable non-device font on printer
1988 if( pInfo->mbPrinter )
1989 if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
1990 return 1;
1991
1992 ImplWinFontData* pData = ImplLogMetricToDevFontDataA( pLogFont, &(pMetric->ntmTm), nFontType );
1993 pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
1994
1995 // prefer the system character set, so that we get as much as
1996 // possible important characters. In the other case we could only
1997 // display a limited set of characters (#87309#)
1998 if ( pInfo->mnPreferedCharSet == pLogFont->elfLogFont.lfCharSet )
1999 pData->mnQuality += 100;
2000
2001 // knowing Courier to be scalable is nice
2002 if( pInfo->mbCourier )
2003 pInfo->mbImplSalCourierScalable |= pData->IsScalable();
2004
2005 pInfo->mpList->Add( pData );
2006 }
2007
2008 return 1;
2009 }
2010
2011 // -----------------------------------------------------------------------
2012
2013 int CALLBACK SalEnumFontsProcExW( const ENUMLOGFONTEXW* pLogFont,
2014 const NEWTEXTMETRICEXW* pMetric,
2015 DWORD nFontType, LPARAM lParam )
2016 {
2017 ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
2018 if ( !pInfo->mpName )
2019 {
2020 // Ignore vertical fonts
2021 if ( pLogFont->elfLogFont.lfFaceName[0] != '@' )
2022 {
2023 if ( !pInfo->mbImplSalCourierNew )
2024 pInfo->mbImplSalCourierNew = ImplSalWICompareAscii( pLogFont->elfLogFont.lfFaceName, "Courier New" ) == 0;
2025 if ( !pInfo->mbImplSalCourierScalable )
2026 pInfo->mbCourier = ImplSalWICompareAscii( pLogFont->elfLogFont.lfFaceName, "Courier" ) == 0;
2027 else
2028 pInfo->mbCourier = FALSE;
2029 String aName( reinterpret_cast<const sal_Unicode*>(pLogFont->elfLogFont.lfFaceName) );
2030 pInfo->mpName = &aName;
2031 memcpy( pInfo->mpLogFontW->lfFaceName, pLogFont->elfLogFont.lfFaceName, (aName.Len()+1)*sizeof( wchar_t ) );
2032 pInfo->mpLogFontW->lfCharSet = pLogFont->elfLogFont.lfCharSet;
2033 EnumFontFamiliesExW( pInfo->mhDC, pInfo->mpLogFontW, (FONTENUMPROCW)SalEnumFontsProcExW,
2034 (LPARAM)(void*)pInfo, 0 );
2035 pInfo->mpLogFontW->lfFaceName[0] = '\0';
2036 pInfo->mpLogFontW->lfCharSet = DEFAULT_CHARSET;
2037 pInfo->mpName = NULL;
2038 pInfo->mbCourier = FALSE;
2039 }
2040 }
2041 else
2042 {
2043 // ignore non-scalable non-device font on printer
2044 if( pInfo->mbPrinter )
2045 if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
2046 return 1;
2047
2048 ImplWinFontData* pData = ImplLogMetricToDevFontDataW( pLogFont, &(pMetric->ntmTm), nFontType );
2049 pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
2050
2051 // knowing Courier to be scalable is nice
2052 if( pInfo->mbCourier )
2053 pInfo->mbImplSalCourierScalable |= pData->IsScalable();
2054
2055 pInfo->mpList->Add( pData );
2056 }
2057
2058 return 1;
2059 }
2060
2061 // -----------------------------------------------------------------------
2062
2063 struct TempFontItem
2064 {
2065 ::rtl::OUString maFontFilePath;
2066 ::rtl::OString maResourcePath;
2067 TempFontItem* mpNextItem;
2068 };
2069
2070 #ifdef FR_PRIVATE
2071 static int WINAPI __AddFontResourceExW( LPCWSTR lpszfileName, DWORD fl, PVOID pdv )
2072 {
2073 typedef int (WINAPI *AddFontResourceExW_FUNC)(LPCWSTR, DWORD, PVOID );
2074
2075 static AddFontResourceExW_FUNC pFunc = NULL;
2076 static HMODULE hmGDI = NULL;
2077
2078 if ( !pFunc && !hmGDI )
2079 {
2080 hmGDI = GetModuleHandleA( "GDI32" );
2081 if ( hmGDI )
2082 pFunc = reinterpret_cast<AddFontResourceExW_FUNC>( GetProcAddress( hmGDI, "AddFontResourceExW" ) );
2083 }
2084
2085 if ( pFunc )
2086 return pFunc( lpszfileName, fl, pdv );
2087 else
2088 {
2089 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2090 return 0;
2091 }
2092 }
2093 #endif
2094
2095 bool ImplAddTempFont( SalData& rSalData, const String& rFontFileURL )
2096 {
2097 int nRet = 0;
2098 ::rtl::OUString aUSytemPath;
2099 OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
2100
2101 #ifdef FR_PRIVATE
2102 nRet = __AddFontResourceExW( reinterpret_cast<LPCWSTR>(aUSytemPath.getStr()), FR_PRIVATE, NULL );
2103 #endif
2104
2105 if ( !nRet )
2106 {
2107 static int nCounter = 0;
2108 char aFileName[] = "soAA.fot";
2109 aFileName[2] = sal::static_int_cast<char>('A' + (15 & (nCounter>>4)));
2110 aFileName[3] = sal::static_int_cast<char>('A' + (15 & nCounter));
2111 char aResourceName[512];
2112 int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
2113 int nLen = ::GetTempPathA( nMaxLen, aResourceName );
2114 ::strncpy( aResourceName + nLen, aFileName, sizeof( aResourceName )- nLen );
2115 // security: end buffer in any case
2116 aResourceName[ (sizeof(aResourceName)/sizeof(*aResourceName))-1 ] = 0;
2117 ::DeleteFileA( aResourceName );
2118
2119 rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
2120 ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
2121 // TODO: font should be private => need to investigate why it doesn't work then
2122 if( !::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL ) )
2123 return false;
2124 ++nCounter;
2125
2126 nRet = ::AddFontResourceA( aResourceName );
2127 if( nRet > 0 )
2128 {
2129 TempFontItem* pNewItem = new TempFontItem;
2130 pNewItem->maResourcePath = rtl::OString( aResourceName );
2131 pNewItem->maFontFilePath = aUSytemPath.getStr();
2132 pNewItem->mpNextItem = rSalData.mpTempFontItem;
2133 rSalData.mpTempFontItem = pNewItem;
2134 }
2135 }
2136
2137 return (nRet > 0);
2138 }
2139
2140 // -----------------------------------------------------------------------
2141
2142 void ImplReleaseTempFonts( SalData& rSalData )
2143 {
2144 int nCount = 0;
2145 while( TempFontItem* p = rSalData.mpTempFontItem )
2146 {
2147 ++nCount;
2148 if( p->maResourcePath.getLength() )
2149 {
2150 const char* pResourcePath = p->maResourcePath.getStr();
2151 ::RemoveFontResourceA( pResourcePath );
2152 ::DeleteFileA( pResourcePath );
2153 }
2154 else
2155 {
2156 ::RemoveFontResourceW( reinterpret_cast<LPCWSTR>(p->maFontFilePath.getStr()) );
2157 }
2158
2159 rSalData.mpTempFontItem = p->mpNextItem;
2160 delete p;
2161 }
2162
2163 #ifndef FR_PRIVATE
2164 // notify every other application
2165 // unless the temp fonts were installed as private fonts
2166 if( nCount > 0 )
2167 ::PostMessage( HWND_BROADCAST, WM_FONTCHANGE, 0, NULL );
2168 #endif // FR_PRIVATE
2169 }
2170
2171 // -----------------------------------------------------------------------
2172
2173 static bool ImplGetFontAttrFromFile( const String& rFontFileURL,
2174 ImplDevFontAttributes& rDFA )
2175 {
2176 ::rtl::OUString aUSytemPath;
2177 OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
2178
2179 // get FontAttributes from a *fot file
2180 // TODO: use GetTTGlobalFontInfo() to access the font directly
2181 rDFA.mnQuality = 1000;
2182 rDFA.mbDevice = true;
2183 rDFA.meFamily = FAMILY_DONTKNOW;
2184 rDFA.meWidthType = WIDTH_DONTKNOW;
2185 rDFA.meWeight = WEIGHT_DONTKNOW;
2186 rDFA.meItalic = ITALIC_DONTKNOW;
2187 rDFA.mePitch = PITCH_DONTKNOW;;
2188 rDFA.mbSubsettable= true;
2189 rDFA.mbEmbeddable = false;
2190
2191 // Create temporary file name
2192 char aFileName[] = "soAAT.fot";
2193 char aResourceName[512];
2194 int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
2195 int nLen = ::GetTempPathA( nMaxLen, aResourceName );
2196 ::strncpy( aResourceName + nLen, aFileName, Max( 0, nMaxLen - nLen ));
2197 ::DeleteFileA( aResourceName );
2198
2199 // Create font resource file (typically with a .fot file name extension).
2200 rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
2201 ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
2202 ::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL );
2203
2204 // Open and read the font resource file
2205 rtl::OUString aFotFileName = rtl::OStringToOUString( aResourceName, osl_getThreadTextEncoding() );
2206 osl::FileBase::getFileURLFromSystemPath( aFotFileName, aFotFileName );
2207 osl::File aFotFile( aFotFileName );
2208 osl::FileBase::RC aError = aFotFile.open( osl_File_OpenFlag_Read );
2209 if( aError != osl::FileBase::E_None )
2210 return false;
2211
2212 sal_uInt64 nBytesRead = 0;
2213 char aBuffer[4096];
2214 aFotFile.read( aBuffer, sizeof( aBuffer ), nBytesRead );
2215 // clean up temporary resource file
2216 aFotFile.close();
2217 ::DeleteFileA( aResourceName );
2218
2219 // retrieve font family name from byte offset 0x4F6
2220 int i = 0x4F6;
2221 int nNameOfs = i;
2222 while( (i < nBytesRead) && (aBuffer[i++] != 0) );
2223 // skip full name
2224 while( (i < nBytesRead) && (aBuffer[i++] != 0) );
2225 // retrieve font style name
2226 int nStyleOfs = i;
2227 while( (i < nBytesRead) && (aBuffer[i++] != 0) );
2228 if( i >= nBytesRead )
2229 return false;
2230
2231 // convert byte strings to unicode
2232 rDFA.maName = String( aBuffer + nNameOfs, osl_getThreadTextEncoding() );
2233 rDFA.maStyleName = String( aBuffer + nStyleOfs, osl_getThreadTextEncoding() );
2234
2235 // byte offset 0x4C7: OS2_fsSelection
2236 const char nFSS = aBuffer[ 0x4C7 ];
2237 if( nFSS & 0x01 ) // italic
2238 rDFA.meItalic = ITALIC_NORMAL;
2239 //if( nFSS & 0x20 ) // bold
2240 // rDFA.meWeight = WEIGHT_BOLD;
2241 if( nFSS & 0x40 ) // regular
2242 {
2243 rDFA.meWeight = WEIGHT_NORMAL;
2244 rDFA.meItalic = ITALIC_NONE;
2245 }
2246
2247 // byte offsets 0x4D7/0x4D8: wingdi's FW_WEIGHT
2248 int nWinWeight = (aBuffer[0x4D7] & 0xFF) + ((aBuffer[0x4D8] & 0xFF) << 8);
2249 rDFA.meWeight = ImplWeightToSal( nWinWeight );
2250
2251 rDFA.mbSymbolFlag = false; // TODO
2252 rDFA.mePitch = PITCH_DONTKNOW; // TODO
2253
2254 // byte offset 0x4DE: pitch&family
2255 rDFA.meFamily = ImplFamilyToSal( aBuffer[0x4DE] );
2256
2257 // byte offsets 0x4C8/0x4C9: emunits
2258 // byte offsets 0x4CE/0x4CF: winascent
2259 // byte offsets 0x4D0/0x4D1: winascent+windescent-emunits
2260 // byte offsets 0x4DF/0x4E0: avgwidth
2261 //...
2262
2263 return true;
2264 }
2265
2266 // -----------------------------------------------------------------------
2267
2268 bool WinSalGraphics::AddTempDevFont( ImplDevFontList* pFontList,
2269 const String& rFontFileURL, const String& rFontName )
2270 {
2271 RTL_LOGFILE_TRACE1( "WinSalGraphics::AddTempDevFont(): %s", rtl::OUStringToOString( rFontFileURL, RTL_TEXTENCODING_UTF8 ).getStr() );
2272
2273 ImplDevFontAttributes aDFA;
2274 aDFA.maName = rFontName;
2275 aDFA.mnQuality = 1000;
2276 aDFA.mbDevice = true;
2277
2278 // Search Font Name in Cache
2279 if( !rFontName.Len() && mpFontAttrCache )
2280 aDFA = mpFontAttrCache->GetFontAttr( rFontFileURL );
2281
2282 // Retrieve font name from font resource
2283 if( !aDFA.maName.Len() )
2284 {
2285 ImplGetFontAttrFromFile( rFontFileURL, aDFA );
2286 if( mpFontAttrCache && aDFA.maName.Len() )
2287 mpFontAttrCache->AddFontAttr( rFontFileURL, aDFA );
2288 }
2289
2290 if ( !aDFA.maName.Len() )
2291 return false;
2292
2293 // remember temp font for cleanup later
2294 if( !ImplAddTempFont( *GetSalData(), rFontFileURL ) )
2295 return false;
2296
2297 UINT nPreferedCharSet = DEFAULT_CHARSET;
2298
2299 // create matching FontData struct
2300 aDFA.mbSymbolFlag = false; // TODO: how to know it without accessing the font?
2301 aDFA.meFamily = FAMILY_DONTKNOW;
2302 aDFA.meWidthType = WIDTH_DONTKNOW;
2303 aDFA.meWeight = WEIGHT_DONTKNOW;
2304 aDFA.meItalic = ITALIC_DONTKNOW;
2305 aDFA.mePitch = PITCH_DONTKNOW;;
2306 aDFA.mbSubsettable= true;
2307 aDFA.mbEmbeddable = false;
2308
2309 /*
2310 // TODO: improve ImplDevFontAttributes using the "font resource file"
2311 aDFS.maName = // using "FONTRES:" from file
2312 if( rFontName != aDFS.maName )
2313 aDFS.maMapName = aFontName;
2314 */
2315
2316 ImplWinFontData* pFontData = new ImplWinFontData( aDFA, 0,
2317 sal::static_int_cast<BYTE>(nPreferedCharSet),
2318 sal::static_int_cast<BYTE>(TMPF_VECTOR|TMPF_TRUETYPE) );
2319 pFontData->SetFontId( reinterpret_cast<sal_IntPtr>(pFontData) );
2320 pFontList->Add( pFontData );
2321 return true;
2322 }
2323
2324 // -----------------------------------------------------------------------
2325
2326 void WinSalGraphics::GetDevFontList( ImplDevFontList* pFontList )
2327 {
2328 // make sure all fonts are registered at least temporarily
2329 static bool bOnce = true;
2330 if( bOnce )
2331 {
2332 bOnce = false;
2333
2334 // determine font path
2335 // since we are only interested in fonts that could not be
2336 // registered before because of missing administration rights
2337 // only the font path of the user installation is needed
2338 ::rtl::OUString aPath;
2339 osl_getExecutableFile( &aPath.pData );
2340 ::rtl::OUString aExecutableFile( aPath );
2341 aPath = aPath.copy( 0, aPath.lastIndexOf('/') );
2342 String aFontDirUrl = aPath.copy( 0, aPath.lastIndexOf('/') );
2343 aFontDirUrl += String( RTL_CONSTASCII_USTRINGPARAM("/Basis/share/fonts/truetype") );
2344
2345 // collect fonts in font path that could not be registered
2346 osl::Directory aFontDir( aFontDirUrl );
2347 osl::FileBase::RC rcOSL = aFontDir.open();
2348 if( rcOSL == osl::FileBase::E_None )
2349 {
2350 osl::DirectoryItem aDirItem;
2351 String aEmptyString;
2352
2353 ::rtl::OUString aBootStrap;
2354 rtl::Bootstrap::get( String( RTL_CONSTASCII_USTRINGPARAM( "BRAND_BASE_DIR" ) ), aBootStrap );
2355 aBootStrap += String( RTL_CONSTASCII_USTRINGPARAM( "/program/" SAL_CONFIGFILE( "bootstrap" ) ) );
2356 rtl::Bootstrap aBootstrap( aBootStrap );
2357 ::rtl::OUString aUserPath;
2358 aBootstrap.getFrom( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserInstallation" ) ), aUserPath );
2359 aUserPath += String( RTL_CONSTASCII_USTRINGPARAM("/user/config/fontnames.dat") );
2360 String aBaseURL = aPath.copy( 0, aPath.lastIndexOf('/')+1 );
2361 mpFontAttrCache = new ImplFontAttrCache( aUserPath, aBaseURL );
2362
2363 while( aFontDir.getNextItem( aDirItem, 10 ) == osl::FileBase::E_None )
2364 {
2365 osl::FileStatus aFileStatus( FileStatusMask_FileURL );
2366 rcOSL = aDirItem.getFileStatus( aFileStatus );
2367 if ( rcOSL == osl::FileBase::E_None )
2368 AddTempDevFont( pFontList, aFileStatus.getFileURL(), aEmptyString );
2369 }
2370
2371 delete mpFontAttrCache; // destructor rewrites the cache file if needed
2372 mpFontAttrCache = NULL;
2373 }
2374 }
2375
2376 ImplEnumInfo aInfo;
2377 aInfo.mhDC = mhDC;
2378 aInfo.mpList = pFontList;
2379 aInfo.mpName = NULL;
2380 aInfo.mpLogFontA = NULL;
2381 aInfo.mpLogFontW = NULL;
2382 aInfo.mbCourier = false;
2383 aInfo.mbPrinter = mbPrinter;
2384 aInfo.mnFontCount = 0;
2385 if ( !mbPrinter )
2386 {
2387 aInfo.mbImplSalCourierScalable = false;
2388 aInfo.mbImplSalCourierNew = false;
2389 }
2390 else
2391 {
2392 aInfo.mbImplSalCourierScalable = true;
2393 aInfo.mbImplSalCourierNew = true;
2394 }
2395
2396 aInfo.mnPreferedCharSet = DEFAULT_CHARSET;
2397 DWORD nCP = GetACP();
2398 CHARSETINFO aCharSetInfo;
2399 if ( TranslateCharsetInfo( (DWORD*)nCP, &aCharSetInfo, TCI_SRCCODEPAGE ) )
2400 aInfo.mnPreferedCharSet = aCharSetInfo.ciCharset;
2401
2402 LOGFONTW aLogFont;
2403 memset( &aLogFont, 0, sizeof( aLogFont ) );
2404 aLogFont.lfCharSet = DEFAULT_CHARSET;
2405 aInfo.mpLogFontW = &aLogFont;
2406 EnumFontFamiliesExW( mhDC, &aLogFont,
2407 (FONTENUMPROCW)SalEnumFontsProcExW, (LPARAM)(void*)&aInfo, 0 );
2408
2409 // Feststellen, was es fuer Courier-Schriften auf dem Bildschirm gibt,
2410 // um in SetFont() evt. Courier auf Courier New zu mappen
2411 if ( !mbPrinter )
2412 {
2413 bImplSalCourierScalable = aInfo.mbImplSalCourierScalable;
2414 bImplSalCourierNew = aInfo.mbImplSalCourierNew;
2415 }
2416
2417 // set glyph fallback hook
2418 static WinGlyphFallbackSubstititution aSubstFallback( mhDC );
2419 pFontList->SetFallbackHook( &aSubstFallback );
2420 }
2421
2422 // ----------------------------------------------------------------------------
2423
2424 void WinSalGraphics::GetDevFontSubstList( OutputDevice* )
2425 {}
2426
2427 // -----------------------------------------------------------------------
2428
2429 sal_Bool WinSalGraphics::GetGlyphBoundRect( long nIndex, Rectangle& rRect )
2430 {
2431 HDC hDC = mhDC;
2432
2433 // use unity matrix
2434 MAT2 aMat;
2435 aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
2436 aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
2437
2438 UINT nGGOFlags = GGO_METRICS;
2439 if( !(nIndex & GF_ISCHAR) )
2440 nGGOFlags |= GGO_GLYPH_INDEX;
2441 nIndex &= GF_IDXMASK;
2442
2443 GLYPHMETRICS aGM;
2444 aGM.gmptGlyphOrigin.x = aGM.gmptGlyphOrigin.y = 0;
2445 aGM.gmBlackBoxX = aGM.gmBlackBoxY = 0;
2446 DWORD nSize = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGM, 0, NULL, &aMat );
2447 if( nSize == GDI_ERROR )
2448 return false;
2449
2450 rRect = Rectangle( Point( +aGM.gmptGlyphOrigin.x, -aGM.gmptGlyphOrigin.y ),
2451 Size( aGM.gmBlackBoxX, aGM.gmBlackBoxY ) );
2452 rRect.Left() = static_cast<int>( mfFontScale * rRect.Left() );
2453 rRect.Right() = static_cast<int>( mfFontScale * rRect.Right() );
2454 rRect.Top() = static_cast<int>( mfFontScale * rRect.Top() );
2455 rRect.Bottom() = static_cast<int>( mfFontScale * rRect.Bottom() );
2456 return true;
2457 }
2458
2459 // -----------------------------------------------------------------------
2460
2461 sal_Bool WinSalGraphics::GetGlyphOutline( long nIndex,
2462 ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
2463 {
2464 rB2DPolyPoly.clear();
2465
2466 HDC hDC = mhDC;
2467
2468 // use unity matrix
2469 MAT2 aMat;
2470 aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
2471 aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
2472
2473 UINT nGGOFlags = GGO_NATIVE;
2474 if( !(nIndex & GF_ISCHAR) )
2475 nGGOFlags |= GGO_GLYPH_INDEX;
2476 nIndex &= GF_IDXMASK;
2477
2478 GLYPHMETRICS aGlyphMetrics;
2479 const DWORD nSize1 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGlyphMetrics, 0, NULL, &aMat );
2480 if( !nSize1 ) // blank glyphs are ok
2481 return TRUE;
2482 else if( nSize1 == GDI_ERROR )
2483 return FALSE;
2484
2485 BYTE* pData = new BYTE[ nSize1 ];
2486 const DWORD nSize2 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags,
2487 &aGlyphMetrics, nSize1, pData, &aMat );
2488
2489 if( nSize1 != nSize2 )
2490 return FALSE;
2491
2492 // TODO: avoid tools polygon by creating B2DPolygon directly
2493 int nPtSize = 512;
2494 Point* pPoints = new Point[ nPtSize ];
2495 BYTE* pFlags = new BYTE[ nPtSize ];
2496
2497 TTPOLYGONHEADER* pHeader = (TTPOLYGONHEADER*)pData;
2498 while( (BYTE*)pHeader < pData+nSize2 )
2499 {
2500 // only outline data is interesting
2501 if( pHeader->dwType != TT_POLYGON_TYPE )
2502 break;
2503
2504 // get start point; next start points are end points
2505 // of previous segment
2506 USHORT nPnt = 0;
2507
2508 long nX = IntTimes256FromFixed( pHeader->pfxStart.x );
2509 long nY = IntTimes256FromFixed( pHeader->pfxStart.y );
2510 pPoints[ nPnt ] = Point( nX, nY );
2511 pFlags[ nPnt++ ] = POLY_NORMAL;
2512
2513 bool bHasOfflinePoints = false;
2514 TTPOLYCURVE* pCurve = (TTPOLYCURVE*)( pHeader + 1 );
2515 pHeader = (TTPOLYGONHEADER*)( (BYTE*)pHeader + pHeader->cb );
2516 while( (BYTE*)pCurve < (BYTE*)pHeader )
2517 {
2518 int nNeededSize = nPnt + 16 + 3 * pCurve->cpfx;
2519 if( nPtSize < nNeededSize )
2520 {
2521 Point* pOldPoints = pPoints;
2522 BYTE* pOldFlags = pFlags;
2523 nPtSize = 2 * nNeededSize;
2524 pPoints = new Point[ nPtSize ];
2525 pFlags = new BYTE[ nPtSize ];
2526 for( USHORT i = 0; i < nPnt; ++i )
2527 {
2528 pPoints[ i ] = pOldPoints[ i ];
2529 pFlags[ i ] = pOldFlags[ i ];
2530 }
2531 delete[] pOldPoints;
2532 delete[] pOldFlags;
2533 }
2534
2535 int i = 0;
2536 if( TT_PRIM_LINE == pCurve->wType )
2537 {
2538 while( i < pCurve->cpfx )
2539 {
2540 nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
2541 nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
2542 ++i;
2543 pPoints[ nPnt ] = Point( nX, nY );
2544 pFlags[ nPnt ] = POLY_NORMAL;
2545 ++nPnt;
2546 }
2547 }
2548 else if( TT_PRIM_QSPLINE == pCurve->wType )
2549 {
2550 bHasOfflinePoints = true;
2551 while( i < pCurve->cpfx )
2552 {
2553 // get control point of quadratic bezier spline
2554 nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
2555 nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
2556 ++i;
2557 Point aControlP( nX, nY );
2558
2559 // calculate first cubic control point
2560 // P0 = 1/3 * (PBeg + 2 * PQControl)
2561 nX = pPoints[ nPnt-1 ].X() + 2 * aControlP.X();
2562 nY = pPoints[ nPnt-1 ].Y() + 2 * aControlP.Y();
2563 pPoints[ nPnt+0 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
2564 pFlags[ nPnt+0 ] = POLY_CONTROL;
2565
2566 // calculate endpoint of segment
2567 nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
2568 nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
2569
2570 if ( i+1 >= pCurve->cpfx )
2571 {
2572 // endpoint is either last point in segment => advance
2573 ++i;
2574 }
2575 else
2576 {
2577 // or endpoint is the middle of two control points
2578 nX += IntTimes256FromFixed( pCurve->apfx[ i-1 ].x );
2579 nY += IntTimes256FromFixed( pCurve->apfx[ i-1 ].y );
2580 nX = (nX + 1) / 2;
2581 nY = (nY + 1) / 2;
2582 // no need to advance, because the current point
2583 // is the control point in next bezier spline
2584 }
2585
2586 pPoints[ nPnt+2 ] = Point( nX, nY );
2587 pFlags[ nPnt+2 ] = POLY_NORMAL;
2588
2589 // calculate second cubic control point
2590 // P1 = 1/3 * (PEnd + 2 * PQControl)
2591 nX = pPoints[ nPnt+2 ].X() + 2 * aControlP.X();
2592 nY = pPoints[ nPnt+2 ].Y() + 2 * aControlP.Y();
2593 pPoints[ nPnt+1 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
2594 pFlags[ nPnt+1 ] = POLY_CONTROL;
2595
2596 nPnt += 3;
2597 }
2598 }
2599
2600 // next curve segment
2601 pCurve = (TTPOLYCURVE*)&pCurve->apfx[ i ];
2602 }
2603
2604 // end point is start point for closed contour
2605 // disabled, because Polygon class closes the contour itself
2606 // pPoints[nPnt++] = pPoints[0];
2607 // #i35928#
2608 // Added again, but add only when not yet closed
2609 if(pPoints[nPnt - 1] != pPoints[0])
2610 {
2611 if( bHasOfflinePoints )
2612 pFlags[nPnt] = pFlags[0];
2613
2614 pPoints[nPnt++] = pPoints[0];
2615 }
2616
2617 // convert y-coordinates W32 -> VCL
2618 for( int i = 0; i < nPnt; ++i )
2619 pPoints[i].Y() = -pPoints[i].Y();
2620
2621 // insert into polypolygon
2622 Polygon aPoly( nPnt, pPoints, (bHasOfflinePoints ? pFlags : NULL) );
2623 // convert to B2DPolyPolygon
2624 // TODO: get rid of the intermediate PolyPolygon
2625 rB2DPolyPoly.append( aPoly.getB2DPolygon() );
2626 }
2627
2628 delete[] pPoints;
2629 delete[] pFlags;
2630
2631 delete[] pData;
2632
2633 // rescaling needed for the PolyPolygon conversion
2634 if( rB2DPolyPoly.count() )
2635 {
2636 const double fFactor(mfFontScale/256);
2637 rB2DPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix(fFactor, fFactor));
2638 }
2639
2640 return TRUE;
2641 }
2642
2643 // -----------------------------------------------------------------------
2644
2645 class ScopedFont
2646 {
2647 public:
2648 explicit ScopedFont(WinSalGraphics & rData);
2649
2650 ~ScopedFont();
2651
2652 private:
2653 WinSalGraphics & m_rData;
2654 HFONT m_hOrigFont;
2655 };
2656
2657 ScopedFont::ScopedFont(WinSalGraphics & rData): m_rData(rData)
2658 {
2659 m_hOrigFont = m_rData.mhFonts[0];
2660 m_rData.mhFonts[0] = 0; // avoid deletion of current font
2661 }
2662
2663 ScopedFont::~ScopedFont()
2664 {
2665 if( m_hOrigFont )
2666 {
2667 // restore original font, destroy temporary font
2668 HFONT hTempFont = m_rData.mhFonts[0];
2669 m_rData.mhFonts[0] = m_hOrigFont;
2670 SelectObject( m_rData.mhDC, m_hOrigFont );
2671 DeleteObject( hTempFont );
2672 }
2673 }
2674
2675 class ScopedTrueTypeFont
2676 {
2677 public:
2678 inline ScopedTrueTypeFont(): m_pFont(0) {}
2679
2680 ~ScopedTrueTypeFont();
2681
2682 int open(void * pBuffer, sal_uInt32 nLen, sal_uInt32 nFaceNum);
2683
2684 inline TrueTypeFont * get() const { return m_pFont; }
2685
2686 private:
2687 TrueTypeFont * m_pFont;
2688 };
2689
2690 ScopedTrueTypeFont::~ScopedTrueTypeFont()
2691 {
2692 if (m_pFont != 0)
2693 CloseTTFont(m_pFont);
2694 }
2695
2696 int ScopedTrueTypeFont::open(void * pBuffer, sal_uInt32 nLen,
2697 sal_uInt32 nFaceNum)
2698 {
2699 OSL_ENSURE(m_pFont == 0, "already open");
2700 return OpenTTFontBuffer(pBuffer, nLen, nFaceNum, &m_pFont);
2701 }
2702
2703 sal_Bool WinSalGraphics::CreateFontSubset( const rtl::OUString& rToFile,
2704 const ImplFontData* pFont, long* pGlyphIDs, sal_uInt8* pEncoding,
2705 sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
2706 {
2707 // TODO: use more of the central font-subsetting code, move stuff there if needed
2708
2709 // create matching ImplFontSelectData
2710 // we need just enough to get to the font file data
2711 // use height=1000 for easier debugging (to match psprint's font units)
2712 ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
2713
2714 // TODO: much better solution: move SetFont and restoration of old font to caller
2715 ScopedFont aOldFont(*this);
2716 float fScale = 1.0;
2717 HFONT hOldFont = 0;
2718 ImplDoSetFont( &aIFSD, fScale, hOldFont );
2719
2720 ImplWinFontData* pWinFontData = (ImplWinFontData*)aIFSD.mpFontData;
2721
2722 #if OSL_DEBUG_LEVEL > 1
2723 // get font metrics
2724 TEXTMETRICA aWinMetric;
2725 if( !::GetTextMetricsA( mhDC, &aWinMetric ) )
2726 return FALSE;
2727
2728 DBG_ASSERT( !(aWinMetric.tmPitchAndFamily & TMPF_DEVICE), "cannot subset device font" );
2729 DBG_ASSERT( aWinMetric.tmPitchAndFamily & TMPF_TRUETYPE, "can only subset TT font" );
2730 #endif
2731
2732 rtl::OUString aSysPath;
2733 if( osl_File_E_None != osl_getSystemPathFromFileURL( rToFile.pData, &aSysPath.pData ) )
2734 return FALSE;
2735 const rtl_TextEncoding aThreadEncoding = osl_getThreadTextEncoding();
2736 const ByteString aToFile( aSysPath.getStr(), (xub_StrLen)aSysPath.getLength(), aThreadEncoding );
2737
2738 // check if the font has a CFF-table
2739 const DWORD nCffTag = CalcTag( "CFF " );
2740 const RawFontData aRawCffData( mhDC, nCffTag );
2741 if( aRawCffData.get() )
2742 {
2743 pWinFontData->UpdateFromHDC( mhDC );
2744 const ImplFontCharMap* pCharMap = pWinFontData->GetImplFontCharMap();
2745 pCharMap->AddReference();
2746
2747 long nRealGlyphIds[ 256 ];
2748 for( int i = 0; i < nGlyphCount; ++i )
2749 {
2750 // TODO: remap notdef glyph if needed
2751 // TODO: use GDI's GetGlyphIndices instead? Does it handle GSUB properly?
2752 sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
2753 if( pGlyphIDs[i] & GF_ISCHAR ) // remaining pseudo-glyphs need to be translated
2754 nGlyphIdx = pCharMap->GetGlyphIndex( nGlyphIdx );
2755 if( (pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0) // TODO: vertical substitution
2756 {/*####*/}
2757
2758 nRealGlyphIds[i] = nGlyphIdx;
2759 }
2760
2761 pCharMap->DeReference(); // TODO: and and use a RAII object
2762
2763 // provide a font subset from the CFF-table
2764 FILE* pOutFile = fopen( aToFile.GetBuffer(), "wb" );
2765 rInfo.LoadFont( FontSubsetInfo::CFF_FONT, aRawCffData.get(), aRawCffData.size() );
2766 bool bRC = rInfo.CreateFontSubset( FontSubsetInfo::TYPE1_PFB, pOutFile, NULL,
2767 nRealGlyphIds, pEncoding, nGlyphCount, pGlyphWidths );
2768 fclose( pOutFile );
2769 return bRC;
2770 }
2771
2772 // get raw font file data
2773 const RawFontData xRawFontData( mhDC, NULL );
2774 if( !xRawFontData.get() )
2775 return FALSE;
2776
2777 // open font file
2778 sal_uInt32 nFaceNum = 0;
2779 if( !*xRawFontData.get() ) // TTC candidate
2780 nFaceNum = ~0U; // indicate "TTC font extracts only"
2781
2782 ScopedTrueTypeFont aSftTTF;
2783 int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
2784 if( nRC != SF_OK )
2785 return FALSE;
2786
2787 TTGlobalFontInfo aTTInfo;
2788 ::GetTTGlobalFontInfo( aSftTTF.get(), &aTTInfo );
2789 rInfo.m_nFontType = FontSubsetInfo::SFNT_TTF;
2790 rInfo.m_aPSName = ImplSalGetUniString( aTTInfo.psname );
2791 rInfo.m_nAscent = +aTTInfo.winAscent;
2792 rInfo.m_nDescent = -aTTInfo.winDescent;
2793 rInfo.m_aFontBBox = Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
2794 Point( aTTInfo.xMax, aTTInfo.yMax ) );
2795 rInfo.m_nCapHeight = aTTInfo.yMax; // Well ...
2796
2797 // subset TTF-glyphs and get their properties
2798 // take care that subset fonts require the NotDef glyph in pos 0
2799 int nOrigCount = nGlyphCount;
2800 sal_uInt16 aShortIDs[ 256 ];
2801 sal_uInt8 aTempEncs[ 256 ];
2802
2803 int nNotDef=-1, i;
2804 for( i = 0; i < nGlyphCount; ++i )
2805 {
2806 aTempEncs[i] = pEncoding[i];
2807 sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
2808 if( pGlyphIDs[i] & GF_ISCHAR )
2809 {
2810 sal_Unicode cChar = static_cast<sal_Unicode>(nGlyphIdx); // TODO: sal_UCS4
2811 const bool bVertical = ((pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0);
2812 nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
2813 if( (nGlyphIdx == 0) && pFont->IsSymbolFont() )
2814 {
2815 // #i12824# emulate symbol aliasing U+FXXX <-> U+0XXX
2816 cChar = (cChar & 0xF000) ? (cChar & 0x00FF) : (cChar | 0xF000);
2817 nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
2818 }
2819 }
2820 aShortIDs[i] = static_cast<sal_uInt16>( nGlyphIdx );
2821 if( !nGlyphIdx )
2822 if( nNotDef < 0 )
2823 nNotDef = i; // first NotDef glyph found
2824 }
2825
2826 if( nNotDef != 0 )
2827 {
2828 // add fake NotDef glyph if needed
2829 if( nNotDef < 0 )
2830 nNotDef = nGlyphCount++;
2831
2832 // NotDef glyph must be in pos 0 => swap glyphids
2833 aShortIDs[ nNotDef ] = aShortIDs[0];
2834 aTempEncs[ nNotDef ] = aTempEncs[0];
2835 aShortIDs[0] = 0;
2836 aTempEncs[0] = 0;
2837 }
2838 DBG_ASSERT( nGlyphCount < 257, "too many glyphs for subsetting" );
2839
2840 // fill pWidth array
2841 TTSimpleGlyphMetrics* pMetrics =
2842 ::GetTTSimpleGlyphMetrics( aSftTTF.get(), aShortIDs, nGlyphCount, aIFSD.mbVertical );
2843 if( !pMetrics )
2844 return FALSE;
2845 sal_uInt16 nNotDefAdv = pMetrics[0].adv;
2846 pMetrics[0].adv = pMetrics[nNotDef].adv;
2847 pMetrics[nNotDef].adv = nNotDefAdv;
2848 for( i = 0; i < nOrigCount; ++i )
2849 pGlyphWidths[i] = pMetrics[i].adv;
2850 free( pMetrics );
2851
2852 // write subset into destination file
2853 nRC = ::CreateTTFromTTGlyphs( aSftTTF.get(), aToFile.GetBuffer(), aShortIDs,
2854 aTempEncs, nGlyphCount, 0, NULL, 0 );
2855 return (nRC == SF_OK);
2856 }
2857
2858 //--------------------------------------------------------------------------
2859
2860 const void* WinSalGraphics::GetEmbedFontData( const ImplFontData* pFont,
2861 const sal_Unicode* pUnicodes, sal_Int32* pCharWidths,
2862 FontSubsetInfo& rInfo, long* pDataLen )
2863 {
2864 // create matching ImplFontSelectData
2865 // we need just enough to get to the font file data
2866 ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
2867
2868 // TODO: much better solution: move SetFont and restoration of old font to caller
2869 ScopedFont aOldFont(*this);
2870 SetFont( &aIFSD, 0 );
2871
2872 // get the raw font file data
2873 RawFontData aRawFontData( mhDC );
2874 *pDataLen = aRawFontData.size();
2875 if( !aRawFontData.get() )
2876 return NULL;
2877
2878 // get important font properties
2879 TEXTMETRICA aTm;
2880 if( !::GetTextMetricsA( mhDC, &aTm ) )
2881 *pDataLen = 0;
2882 const bool bPFA = (*aRawFontData.get() < 0x80);
2883 rInfo.m_nFontType = bPFA ? FontSubsetInfo::TYPE1_PFA : FontSubsetInfo::TYPE1_PFB;
2884 WCHAR aFaceName[64];
2885 int nFNLen = ::GetTextFaceW( mhDC, 64, aFaceName );
2886 // #i59854# strip eventual null byte
2887 while( nFNLen > 0 && aFaceName[nFNLen-1] == 0 )
2888 nFNLen--;
2889 if( nFNLen == 0 )
2890 *pDataLen = 0;
2891 rInfo.m_aPSName = String( reinterpret_cast<const sal_Unicode*>(aFaceName), sal::static_int_cast<sal_uInt16>(nFNLen) );
2892 rInfo.m_nAscent = +aTm.tmAscent;
2893 rInfo.m_nDescent = -aTm.tmDescent;
2894 rInfo.m_aFontBBox = Rectangle( Point( -aTm.tmOverhang, -aTm.tmDescent ),
2895 Point( aTm.tmMaxCharWidth, aTm.tmAscent+aTm.tmExternalLeading ) );
2896 rInfo.m_nCapHeight = aTm.tmAscent; // Well ...
2897
2898 // get individual character widths
2899 for( int i = 0; i < 256; ++i )
2900 {
2901 int nCharWidth = 0;
2902 const sal_Unicode cChar = pUnicodes[i];
2903 if( !::GetCharWidth32W( mhDC, cChar, cChar, &nCharWidth ) )
2904 *pDataLen = 0;
2905 pCharWidths[i] = nCharWidth;
2906 }
2907
2908 if( !*pDataLen )
2909 return NULL;
2910
2911 const unsigned char* pData = aRawFontData.steal();
2912 return (void*)pData;
2913 }
2914
2915 //--------------------------------------------------------------------------
2916
2917 void WinSalGraphics::FreeEmbedFontData( const void* pData, long /*nLen*/ )
2918 {
2919 delete[] reinterpret_cast<char*>(const_cast<void*>(pData));
2920 }
2921
2922 //--------------------------------------------------------------------------
2923
2924 const Ucs2SIntMap* WinSalGraphics::GetFontEncodingVector( const ImplFontData* pFont, const Ucs2OStrMap** pNonEncoded )
2925 {
2926 // TODO: even for builtin fonts we get here... why?
2927 if( !pFont->IsEmbeddable() )
2928 return NULL;
2929
2930 // fill the encoding vector
2931 // currently no nonencoded vector
2932 if( pNonEncoded )
2933 *pNonEncoded = NULL;
2934
2935 const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>(pFont);
2936 const Ucs2SIntMap* pEncoding = pWinFontData->GetEncodingVector();
2937 if( pEncoding == NULL )
2938 {
2939 Ucs2SIntMap* pNewEncoding = new Ucs2SIntMap;
2940 #if 0
2941 // TODO: get correct encoding vector
2942 GLYPHSET aGlyphSet;
2943 aGlyphSet.cbThis = sizeof(aGlyphSet);
2944 DWORD aW = ::GetFontUnicodeRanges( mhDC, &aGlyphSet);
2945 #else
2946 for( sal_Unicode i = 32; i < 256; ++i )
2947 (*pNewEncoding)[i] = i;
2948 #endif
2949 pWinFontData->SetEncodingVector( pNewEncoding );
2950 pEncoding = pNewEncoding;
2951 }
2952
2953 return pEncoding;
2954 }
2955
2956 //--------------------------------------------------------------------------
2957
2958 void WinSalGraphics::GetGlyphWidths( const ImplFontData* pFont,
2959 bool bVertical,
2960 Int32Vector& rWidths,
2961 Ucs2UIntMap& rUnicodeEnc )
2962 {
2963 // create matching ImplFontSelectData
2964 // we need just enough to get to the font file data
2965 ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
2966
2967 // TODO: much better solution: move SetFont and restoration of old font to caller
2968 ScopedFont aOldFont(*this);
2969
2970 float fScale = 0.0;
2971 HFONT hOldFont = 0;
2972 ImplDoSetFont( &aIFSD, fScale, hOldFont );
2973
2974 if( pFont->IsSubsettable() )
2975 {
2976 // get raw font file data
2977 const RawFontData xRawFontData( mhDC );
2978 if( !xRawFontData.get() )
2979 return;
2980
2981 // open font file
2982 sal_uInt32 nFaceNum = 0;
2983 if( !*xRawFontData.get() ) // TTC candidate
2984 nFaceNum = ~0U; // indicate "TTC font extracts only"
2985
2986 ScopedTrueTypeFont aSftTTF;
2987 int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
2988 if( nRC != SF_OK )
2989 return;
2990
2991 int nGlyphs = GetTTGlyphCount( aSftTTF.get() );
2992 if( nGlyphs > 0 )
2993 {
2994 rWidths.resize(nGlyphs);
2995 std::vector<sal_uInt16> aGlyphIds(nGlyphs);
2996 for( int i = 0; i < nGlyphs; i++ )
2997 aGlyphIds[i] = sal_uInt16(i);
2998 TTSimpleGlyphMetrics* pMetrics = ::GetTTSimpleGlyphMetrics( aSftTTF.get(),
2999 &aGlyphIds[0],
3000 nGlyphs,
3001 bVertical ? 1 : 0 );
3002 if( pMetrics )
3003 {
3004 for( int i = 0; i< nGlyphs; i++ )
3005 rWidths[i] = pMetrics[i].adv;
3006 free( pMetrics );
3007 rUnicodeEnc.clear();
3008 }
3009 const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFont);
3010 const ImplFontCharMap* pMap = pWinFont->GetImplFontCharMap();
3011 DBG_ASSERT( pMap && pMap->GetCharCount(), "no map" );
3012 pMap->AddReference();
3013
3014 int nCharCount = pMap->GetCharCount();
3015 sal_uInt32 nChar = pMap->GetFirstChar();
3016 for( int i = 0; i < nCharCount; i++ )
3017 {
3018 if( nChar < 0x00010000 )
3019 {
3020 sal_uInt16 nGlyph = ::MapChar( aSftTTF.get(),
3021 static_cast<sal_Ucs>(nChar),
3022 bVertical ? 1 : 0 );
3023 if( nGlyph )
3024 rUnicodeEnc[ static_cast<sal_Unicode>(nChar) ] = nGlyph;
3025 }
3026 nChar = pMap->GetNextChar( nChar );
3027 }
3028
3029 pMap->DeReference(); // TODO: and and use a RAII object
3030 }
3031 }
3032 else if( pFont->IsEmbeddable() )
3033 {
3034 // get individual character widths
3035 rWidths.clear();
3036 rUnicodeEnc.clear();
3037 rWidths.reserve( 224 );
3038 for( sal_Unicode i = 32; i < 256; ++i )
3039 {
3040 int nCharWidth = 0;
3041 if( ::GetCharWidth32W( mhDC, i, i, &nCharWidth ) )
3042 {
3043 rUnicodeEnc[ i ] = rWidths.size();
3044 rWidths.push_back( nCharWidth );
3045 }
3046 }
3047 }
3048 }
3049
3050 //--------------------------------------------------------------------------
3051
3052 void WinSalGraphics::DrawServerFontLayout( const ServerFontLayout& )
3053 {}
3054
3055 //--------------------------------------------------------------------------
3056
3057 SystemFontData WinSalGraphics::GetSysFontData( int nFallbacklevel ) const
3058 {
3059 SystemFontData aSysFontData;
3060
3061 if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
3062 if (nFallbacklevel < 0 ) nFallbacklevel = 0;
3063
3064 aSysFontData.nSize = sizeof( SystemFontData );
3065 aSysFontData.hFont = mhFonts[nFallbacklevel];
3066 aSysFontData.bFakeBold = false;
3067 aSysFontData.bFakeItalic = false;
3068 aSysFontData.bAntialias = true;
3069 aSysFontData.bVerticalCharacterType = false;
3070
3071 OSL_TRACE("\r\n:WinSalGraphics::GetSysFontData(): FontID: %p, Fallback level: %d",
3072 aSysFontData.hFont,
3073 nFallbacklevel);
3074
3075 return aSysFontData;
3076 }
3077
3078 //--------------------------------------------------------------------------
3079
FREE OFFICE SUITE