PageRenderTime 62ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/vcl/win/source/gdi/salgdi3.cxx

https://bitbucket.org/markjenkins/libreoffice_ubuntu-debian-fixes
C++ | 2927 lines | 2142 code | 438 blank | 347 comment | 433 complexity | ba4653278a575b9dcd8f2bc228c67501 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0, MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause-No-Nuclear-License-2014 
    

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    2. 

  2. /*
    3. 

  3.  * This file is part of the LibreOffice project.
    4. 

  4.  *
    5. 

  5.  * This Source Code Form is subject to the terms of the Mozilla Public
    6. 

  6.  * License, v. 2.0. If a copy of the MPL was not distributed with this
    7. 

  7.  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
    8. 

  8.  *
    9. 

  9.  * This file incorporates work covered by the following license notice:
    10. 

  10.  *
    11. 

  11.  *   Licensed to the Apache Software Foundation (ASF) under one or more
    12. 

  12.  *   contributor license agreements. See the NOTICE file distributed
    13. 

  13.  *   with this work for additional information regarding copyright
    14. 

  14.  *   ownership. The ASF licenses this file to you under the Apache
    15. 

  15.  *   License, Version 2.0 (the "License"); you may not use this file
    16. 

  16.  *   except in compliance with the License. You may obtain a copy of
    17. 

  17.  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
    18. 

  18.  */
    19. 

  19. 

  20. 

  21. #include <string.h>
    22. 

  22. #include <malloc.h>
    23. 

  23. 

  24. #include <svsys.h>
    25. 

  25. #include "rtl/logfile.hxx"
    26. 

  26. #include "rtl/tencinfo.h"
    27. 

  27. #include "rtl/textcvt.h"
    28. 

  28. #include "rtl/bootstrap.hxx"
    29. 

  29. 

  30. #include "i18npool/mslangid.hxx"
    31. 

  31. #include "i18npool/languagetag.hxx"
    32. 

  32. 

  33. #include "osl/module.h"
    34. 

  34. #include "osl/file.hxx"
    35. 

  35. #include "osl/thread.hxx"
    36. 

  36. #include "osl/process.h"
    37. 

  37. 

  38. #include "basegfx/polygon/b2dpolygon.hxx"
    39. 

  39. #include "basegfx/polygon/b2dpolypolygon.hxx"
    40. 

  40. #include "basegfx/matrix/b2dhommatrix.hxx"
    41. 

  41. #include "basegfx/matrix/b2dhommatrixtools.hxx"
    42. 

  42. 

  43. #include "unotools/fontcfg.hxx" // for IMPL_FONT_ATTR_SYMBOL
    44. 

  44. 

  45. #include "vcl/font.hxx"
    46. 

  46. #include "vcl/svapp.hxx"
    47. 

  47. 

  48. #include "tools/poly.hxx"
    49. 

  49. #include "tools/debug.hxx"
    50. 

  50. #include "tools/stream.hxx"
    51. 

  51. #include "tools/helpers.hxx"
    52. 

  52. 

  53. #include <vcl/sysdata.hxx>
    54. 

  54. 

  55. #include "win/wincomp.hxx"
    56. 

  56. #include "win/saldata.hxx"
    57. 

  57. #include "win/salgdi.h"
    58. 

  58. 

  59. #include "outfont.hxx"
    60. 

  60. #include "fontsubset.hxx"
    61. 

  61. #include "sallayout.hxx"
    62. 

  62. #include "outdev.h"         // for ImplGlyphFallbackFontSubstitution
    63. 

  63. #include "sft.hxx"
    64. 

  64. 

  65. #include <algorithm>
    66. 

  66. 

  67. #ifdef ENABLE_GRAPHITE
    68. 

  68. #include <graphite2/Font.h>
    69. 

  69. #endif
    70. 

  70. 

  71. #include <vector>
    72. 

  72. #include <set>
    73. 

  73. #include <map>
    74. 

  74. 

  75. using namespace vcl;
    76. 

  76. 

  77. static const int MAXFONTHEIGHT = 2048;
    78. 

  78. 

  79. // -----------
    80. 

  80. // - Inlines -
    81. 

  81. // -----------
    82. 

  82. 

  83. inline FIXED FixedFromDouble( double d )
    84. 

  84. {
    85. 

  85.     const long l = (long) ( d * 65536. );
    86. 

  86.     return *(FIXED*) &l;
    87. 

  87. }
    88. 

  88. 

  89. // -----------------------------------------------------------------------
    90. 

  90. 

  91. inline int IntTimes256FromFixed(FIXED f)
    92. 

  92. {
    93. 

  93.     int nFixedTimes256 = (f.value << 8) + ((f.fract+0x80) >> 8);
    94. 

  94.     return nFixedTimes256;
    95. 

  95. }
    96. 

  96. 

  97. // =======================================================================
    98. 

  98. 

  99. // these variables can be static because they store system wide settings
    100. 

  100. static bool bImplSalCourierScalable = false;
    101. 

  101. static bool bImplSalCourierNew = false;
    102. 

  102. 

  103. 

  104. // =======================================================================
    105. 

  105. 

  106. // -----------------------------------------------------------------------
    107. 

  107. 

  108. // TODO: also support temporary TTC font files
    109. 

  109. typedef std::map< String, ImplDevFontAttributes > FontAttrMap;
    110. 

  110. 

  111. class ImplFontAttrCache
    112. 

  112. {
    113. 

  113. private:
    114. 

  114.     FontAttrMap     aFontAttributes;
    115. 

  115.     rtl::OUString   aCacheFileName;
    116. 

  116.     String          aBaseURL;
    117. 

  117.     sal_Bool            bModified;
    118. 

  118. 

  119. protected:
    120. 

  120.     String  OptimizeURL( const String& rURL ) const;
    121. 

  121. 

  122.     enum{ MAGIC = 0x12349876 }; // change if fontattrcache format changes
    123. 

  123. 

  124. public:
    125. 

  125.             ImplFontAttrCache( const String& rCacheFileName, const String& rBaseURL );
    126. 

  126.             ~ImplFontAttrCache();
    127. 

  127. 

  128.     ImplDevFontAttributes  GetFontAttr( const String& rFontFileName ) const;
    129. 

  129.     void                   AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& );
    130. 

  130. };
    131. 

  131. 

  132. ImplFontAttrCache::ImplFontAttrCache( const String& rFileNameURL, const String& rBaseURL ) : aBaseURL( rBaseURL )
    133. 

  133. {
    134. 

  134.     bModified = FALSE;
    135. 

  135.     aBaseURL.ToLowerAscii();    // Windows only, no problem...
    136. 

  136. 

  137.     // open the cache file
    138. 

  138.     osl::FileBase::getSystemPathFromFileURL( rFileNameURL, aCacheFileName );
    139. 

  139.     SvFileStream aCacheFile( aCacheFileName, STREAM_READ );
    140. 

  140.     if( !aCacheFile.IsOpen() )
    141. 

  141.         return;
    142. 

  142. 

  143.     // check the cache version
    144. 

  144.     sal_uInt32 nCacheMagic;
    145. 

  145.     aCacheFile >> nCacheMagic;
    146. 

  146.     if( nCacheMagic != ImplFontAttrCache::MAGIC )
    147. 

  147.         return;  // ignore cache and rewrite if no match
    148. 

  148. 

  149.     // read the cache entries from the file
    150. 

  150.     String aFontFileURL, aFontName;
    151. 

  151.     ImplDevFontAttributes aDFA;
    152. 

  152.     for(;;)
    153. 

  153.     {
    154. 

  154.         aFontFileURL = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(aCacheFile, RTL_TEXTENCODING_UTF8);
    155. 

  155.         if( !aFontFileURL.Len() )
    156. 

  156.             break;
    157. 

  157.         aDFA.maName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(aCacheFile, RTL_TEXTENCODING_UTF8);
    158. 

  158. 

  159.         short n;
    160. 

  160.         aCacheFile >> n; aDFA.meWeight     = static_cast<FontWeight>(n);
    161. 

  161.         aCacheFile >> n; aDFA.meItalic     = static_cast<FontItalic>(n);
    162. 

  162.         aCacheFile >> n; aDFA.mePitch      = static_cast<FontPitch>(n);
    163. 

  163.         aCacheFile >> n; aDFA.meWidthType  = static_cast<FontWidth>(n);
    164. 

  164.         aCacheFile >> n; aDFA.meFamily     = static_cast<FontFamily>(n);
    165. 

  165.         aCacheFile >> n; aDFA.mbSymbolFlag = (n != 0);
    166. 

  166. 

  167.         aCacheFile.ReadByteStringLine( aDFA.maStyleName, RTL_TEXTENCODING_UTF8 );
    168. 

  168. 

  169.         aFontAttributes[ aFontFileURL ] = aDFA;
    170. 

  170.     }
    171. 

  171. }
    172. 

  172. 

  173. ImplFontAttrCache::~ImplFontAttrCache()
    174. 

  174. {
    175. 

  175.     if ( bModified )
    176. 

  176.     {
    177. 

  177.         SvFileStream aCacheFile( aCacheFileName, STREAM_WRITE|STREAM_TRUNC );
    178. 

  178.         if ( aCacheFile.IsWritable() )
    179. 

  179.         {
    180. 

  180.             sal_uInt32 nCacheMagic = ImplFontAttrCache::MAGIC;
    181. 

  181.             aCacheFile << nCacheMagic;
    182. 

  182. 

  183.             // write the cache entries to the file
    184. 

  184.             FontAttrMap::const_iterator aIter = aFontAttributes.begin();
    185. 

  185.             while ( aIter != aFontAttributes.end() )
    186. 

  186.             {
    187. 

  187.                 const String rFontFileURL( (*aIter).first );
    188. 

  188.                 const ImplDevFontAttributes& rDFA( (*aIter).second );
    189. 

  189.                 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(aCacheFile, rFontFileURL, RTL_TEXTENCODING_UTF8);
    190. 

  190.                 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(aCacheFile, rDFA.maName, RTL_TEXTENCODING_UTF8);
    191. 

  191. 

  192.                 aCacheFile << static_cast<short>(rDFA.meWeight);
    193. 

  193.                 aCacheFile << static_cast<short>(rDFA.meItalic);
    194. 

  194.                 aCacheFile << static_cast<short>(rDFA.mePitch);
    195. 

  195.                 aCacheFile << static_cast<short>(rDFA.meWidthType);
    196. 

  196.                 aCacheFile << static_cast<short>(rDFA.meFamily);
    197. 

  197.                 aCacheFile << static_cast<short>(rDFA.mbSymbolFlag != false);
    198. 

  198. 

  199.                 write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(aCacheFile, rDFA.maStyleName, RTL_TEXTENCODING_UTF8);
    200. 

  200. 

  201.                 ++aIter;
    202. 

  202.             }
    203. 

  203.             // EOF Marker
    204. 

  204.             write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(aCacheFile, rtl::OString());
    205. 

  205.         }
    206. 

  206.     }
    207. 

  207. }
    208. 

  208. 

  209. String ImplFontAttrCache::OptimizeURL( const String& rURL ) const
    210. 

  210. {
    211. 

  211.     String aOptimizedFontFileURL( rURL );
    212. 

  212.     aOptimizedFontFileURL.ToLowerAscii();   // Windows only, no problem...
    213. 

  213.     if ( aOptimizedFontFileURL.CompareTo( aBaseURL, aBaseURL.Len() ) == COMPARE_EQUAL )
    214. 

  214.         aOptimizedFontFileURL = aOptimizedFontFileURL.Copy( aBaseURL.Len() );
    215. 

  215.     return aOptimizedFontFileURL;
    216. 

  216. }
    217. 

  217. 

  218. ImplDevFontAttributes ImplFontAttrCache::GetFontAttr( const String& rFontFileName ) const
    219. 

  219. {
    220. 

  220.     ImplDevFontAttributes aDFA;
    221. 

  221.     FontAttrMap::const_iterator it = aFontAttributes.find( OptimizeURL( rFontFileName ) );
    222. 

  222.     if( it != aFontAttributes.end() )
    223. 

  223.     {
    224. 

  224.         aDFA = it->second;
    225. 

  225.     }
    226. 

  226.     return aDFA;
    227. 

  227. }
    228. 

  228. 

  229. void ImplFontAttrCache::AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& rDFA )
    230. 

  230. {
    231. 

  231.     DBG_ASSERT( rFontFileName.Len() && rDFA.maName.Len(), "ImplFontNameCache::AddFontName - invalid data!" );
    232. 

  232.     if ( rFontFileName.Len() && rDFA.maName.Len() )
    233. 

  233.     {
    234. 

  234.         aFontAttributes.insert( FontAttrMap::value_type( OptimizeURL( rFontFileName ), rDFA ) );
    235. 

  235.         bModified = TRUE;
    236. 

  236.     }
    237. 

  237. }
    238. 

  238. 

  239. // =======================================================================
    240. 

  240. 

  241. // raw font data with a scoped lifetime
    242. 

  242. class RawFontData
    243. 

  243. {
    244. 

  244. public:
    245. 

  245.     explicit    RawFontData( HDC, DWORD nTableTag=0 );
    246. 

  246.                 ~RawFontData() { delete[] mpRawBytes; }
    247. 

  247.     const unsigned char*    get() const { return mpRawBytes; }
    248. 

  248.     const unsigned char*    steal() { unsigned char* p = mpRawBytes; mpRawBytes = NULL; return p; }
    249. 

  249.     int               size() const { return mnByteCount; }
    250. 

  250. 

  251. private:
    252. 

  252.     unsigned char*  mpRawBytes;
    253. 

  253.     unsigned        mnByteCount;
    254. 

  254. };
    255. 

  255. 

  256. RawFontData::RawFontData( HDC hDC, DWORD nTableTag )
    257. 

  257. :   mpRawBytes( NULL )
    258. 

  258. ,   mnByteCount( 0 )
    259. 

  259. {
    260. 

  260.     // get required size in bytes
    261. 

  261.     mnByteCount = ::GetFontData( hDC, nTableTag, 0, NULL, 0 );
    262. 

  262.     if( mnByteCount == GDI_ERROR )
    263. 

  263.         return;
    264. 

  264.     else if( !mnByteCount )
    265. 

  265.         return;
    266. 

  266. 

  267.     // allocate the array
    268. 

  268.     mpRawBytes = new unsigned char[ mnByteCount ];
    269. 

  269. 

  270.     // get raw data in chunks small enough for GetFontData()
    271. 

  271.     unsigned nRawDataOfs = 0;
    272. 

  272.     DWORD nMaxChunkSize = 0x100000;
    273. 

  273.     for(;;)
    274. 

  274.     {
    275. 

  275.         // calculate remaining raw data to get
    276. 

  276.         DWORD nFDGet = mnByteCount - nRawDataOfs;
    277. 

  277.         if( nFDGet <= 0 )
    278. 

  278.             break;
    279. 

  279.         // #i56745# limit GetFontData requests
    280. 

  280.         if( nFDGet > nMaxChunkSize )
    281. 

  281.             nFDGet = nMaxChunkSize;
    282. 

  282.         const DWORD nFDGot = ::GetFontData( hDC, nTableTag, nRawDataOfs,
    283. 

  283.             (void*)(mpRawBytes + nRawDataOfs), nFDGet );
    284. 

  284.         if( !nFDGot )
    285. 

  285.             break;
    286. 

  286.         else if( nFDGot != GDI_ERROR )
    287. 

  287.             nRawDataOfs += nFDGot;
    288. 

  288.         else
    289. 

  289.         {
    290. 

  290.             // was the chunk too big? reduce it
    291. 

  291.             nMaxChunkSize /= 2;
    292. 

  292.             if( nMaxChunkSize < 0x10000 )
    293. 

  293.                 break;
    294. 

  294.         }
    295. 

  295.     }
    296. 

  296. 

  297.     // cleanup if the raw data is incomplete
    298. 

  298.     if( nRawDataOfs != mnByteCount )
    299. 

  299.     {
    300. 

  300.         delete[] mpRawBytes;
    301. 

  301.         mpRawBytes = NULL;
    302. 

  302.     }
    303. 

  303. }
    304. 

  304. 

  305. // ===========================================================================
    306. 

  306. // platform specific font substitution hooks for glyph fallback enhancement
    307. 

  307. // TODO: move into i18n module (maybe merge with svx/ucsubset.*
    308. 

  308. //       or merge with i18nutil/source/utility/unicode_data.h)
    309. 

  309. struct Unicode2LangType
    310. 

  310. {
    311. 

  311.     sal_UCS4 mnMinCode;
    312. 

  312.     sal_UCS4 mnMaxCode;
    313. 

  313.     LanguageType mnLangID;
    314. 

  314. };
    315. 

  315. 

  316. // entries marked with default-CJK get replaced with the default-CJK language
    317. 

  317. #define LANGUAGE_DEFAULT_CJK 0xFFF0
    318. 

  318. 

  319. // map unicode ranges to languages supported by OOo
    320. 

  320. // NOTE: due to the binary search used this list must be sorted by mnMinCode
    321. 

  321. static Unicode2LangType aLangFromCodeChart[]= {
    322. 

  322.     {0x0000, 0x007F, LANGUAGE_ENGLISH},             // Basic Latin
    323. 

  323.     {0x0080, 0x024F, LANGUAGE_ENGLISH},             // Latin Extended-A and Latin Extended-B
    324. 

  324.     {0x0250, 0x02AF, LANGUAGE_SYSTEM},              // IPA Extensions
    325. 

  325.     {0x0370, 0x03FF, LANGUAGE_GREEK},               // Greek
    326. 

  326.     {0x0590, 0x05FF, LANGUAGE_HEBREW},              // Hebrew
    327. 

  327.     {0x0600, 0x06FF, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic
    328. 

  328.     {0x0900, 0x097F, LANGUAGE_HINDI},               // Devanagari
    329. 

  329.     {0x0980, 0x09FF, LANGUAGE_BENGALI},             // Bengali
    330. 

  330.     {0x0A80, 0x0AFF, LANGUAGE_GUJARATI},            // Gujarati
    331. 

  331.     {0x0B00, 0x0B7F, LANGUAGE_ORIYA},               // Oriya
    332. 

  332.     {0x0B80, 0x0BFF, LANGUAGE_TAMIL},               // Tamil
    333. 

  333.     {0x0C00, 0x0C7F, LANGUAGE_TELUGU},              // Telugu
    334. 

  334.     {0x0C80, 0x0CFF, LANGUAGE_KANNADA},             // Kannada
    335. 

  335.     {0x0D00, 0x0D7F, LANGUAGE_MALAYALAM},           // Malayalam
    336. 

  336.     {0x0D80, 0x0D7F, LANGUAGE_SINHALESE_SRI_LANKA}, // Sinhala
    337. 

  337.     {0x0E00, 0x0E7F, LANGUAGE_THAI},                // Thai
    338. 

  338.     {0x0E80, 0x0EFF, LANGUAGE_LAO},                 // Lao
    339. 

  339.     {0x0F00, 0x0FFF, LANGUAGE_TIBETAN},             // Tibetan
    340. 

  340.     {0x1000, 0x109F, LANGUAGE_BURMESE},             // Burmese
    341. 

  341.     {0x10A0, 0x10FF, LANGUAGE_GEORGIAN},            // Georgian
    342. 

  342.     {0x1100, 0x11FF, LANGUAGE_KOREAN},              // Hangul Jamo, Korean-specific
    343. 

  343. //  {0x1200, 0x139F, LANGUAGE_AMHARIC_ETHIOPIA},    // Ethiopic
    344. 

  344. //  {0x1200, 0x139F, LANGUAGE_TIGRIGNA_ETHIOPIA},   // Ethiopic
    345. 

  345.     {0x13A0, 0x13FF, LANGUAGE_CHEROKEE_UNITED_STATES}, // Cherokee
    346. 

  346. //  {0x1400, 0x167F, LANGUAGE_CANADIAN_ABORIGINAL}, // Canadian Aboriginial Syllabics
    347. 

  347. //  {0x1680, 0x169F, LANGUAGE_OGHAM},               // Ogham
    348. 

  348. //  {0x16A0, 0x16F0, LANGUAGE_RUNIC},               // Runic
    349. 

  349. //  {0x1700, 0x171F, LANGUAGE_TAGALOG},             // Tagalog
    350. 

  350. //  {0x1720, 0x173F, LANGUAGE_HANUNOO},             // Hanunoo
    351. 

  351. //  {0x1740, 0x175F, LANGUAGE_BUHID},               // Buhid
    352. 

  352. //  {0x1760, 0x177F, LANGUAGE_TAGBANWA},            // Tagbanwa
    353. 

  353.     {0x1780, 0x17FF, LANGUAGE_KHMER},               // Khmer
    354. 

  354.     {0x18A0, 0x18AF, LANGUAGE_MONGOLIAN},           // Mongolian
    355. 

  355. //  {0x1900, 0x194F, LANGUAGE_LIMBU},               // Limbu
    356. 

  356. //  {0x1950, 0x197F, LANGUAGE_TAILE},               // Tai Le
    357. 

  357. //  {0x1980, 0x19DF, LANGUAGE_TAILUE},              // Tai Lue
    358. 

  358.     {0x19E0, 0x19FF, LANGUAGE_KHMER},               // Khmer Symbols
    359. 

  359. //  {0x1A00, 0x1A1F, LANGUAGE_BUGINESE},            // Buginese/Lontara
    360. 

  360. //  {0x1B00, 0x1B7F, LANGUAGE_BALINESE},            // Balinese
    361. 

  361. //  {0x1D00, 0x1DFF, LANGUAGE_NONE},                // Phonetic Symbols
    362. 

  362.     {0x1E00, 0x1EFF, LANGUAGE_ENGLISH},             // Latin Extended Additional
    363. 

  363.     {0x1F00, 0x1FFF, LANGUAGE_GREEK},               // Greek Extended
    364. 

  364.     {0x2C60, 0x2C7F, LANGUAGE_ENGLISH},             // Latin Extended-C
    365. 

  365.     {0x2E80, 0x2FFf, LANGUAGE_CHINESE_SIMPLIFIED},  // CJK Radicals Supplement + Kangxi Radical + Ideographic Description Characters
    366. 

  366.     {0x3000, 0x303F, LANGUAGE_DEFAULT_CJK},         // CJK Symbols and punctuation
    367. 

  367.     {0x3040, 0x30FF, LANGUAGE_JAPANESE},            // Japanese Hiragana + Katakana
    368. 

  368.     {0x3100, 0x312F, LANGUAGE_CHINESE_TRADITIONAL}, // Bopomofo
    369. 

  369.     {0x3130, 0x318F, LANGUAGE_KOREAN},              // Hangul Compatibility Jamo, Kocrean-specific
    370. 

  370.     {0x3190, 0x319F, LANGUAGE_JAPANESE},            // Kanbun
    371. 

  371.     {0x31A0, 0x31BF, LANGUAGE_CHINESE_TRADITIONAL}, // Bopomofo Extended
    372. 

  372.     {0x31C0, 0x31EF, LANGUAGE_DEFAULT_CJK},         // CJK Ideographs
    373. 

  373.     {0x31F0, 0x31FF, LANGUAGE_JAPANESE},            // Japanese Katakana Phonetic Extensions
    374. 

  374.     {0x3200, 0x321F, LANGUAGE_KOREAN},              // Parenthesized Hangul
    375. 

  375.     {0x3220, 0x325F, LANGUAGE_DEFAULT_CJK},         // Parenthesized Ideographs
    376. 

  376.     {0x3260, 0x327F, LANGUAGE_KOREAN},              // Circled Hangul
    377. 

  377.     {0x3280, 0x32CF, LANGUAGE_DEFAULT_CJK},         // Circled Ideographs
    378. 

  378.     {0x32d0, 0x32FF, LANGUAGE_JAPANESE},            // Japanese Circled Katakana
    379. 

  379.     {0x3400, 0x4DBF, LANGUAGE_DEFAULT_CJK},         // CJK Unified Ideographs Extension A
    380. 

  380.     {0x4E00, 0x9FCF, LANGUAGE_DEFAULT_CJK},         // Unified CJK Ideographs
    381. 

  381.     {0xA720, 0xA7FF, LANGUAGE_ENGLISH},             // Latin Extended-D
    382. 

  382.     {0xAC00, 0xD7AF, LANGUAGE_KOREAN},              // Hangul Syllables, Korean-specific
    383. 

  383.     {0xF900, 0xFAFF, LANGUAGE_DEFAULT_CJK},         // CJK Compatibility Ideographs
    384. 

  384.     {0xFB00, 0xFB4F, LANGUAGE_HEBREW},              // Hebrew Presentation Forms
    385. 

  385.     {0xFB50, 0xFDFF, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic Presentation Forms-A
    386. 

  386.     {0xFE70, 0xFEFE, LANGUAGE_ARABIC_PRIMARY_ONLY}, // Arabic Presentation Forms-B
    387. 

  387.     {0xFF65, 0xFF9F, LANGUAGE_JAPANESE},            // Japanese Halfwidth Katakana variant
    388. 

  388.     {0xFFA0, 0xFFDC, LANGUAGE_KOREAN},              // Kocrean halfwidth hangual variant
    389. 

  389.     {0x10140, 0x1018F, LANGUAGE_GREEK},             // Ancient Greak numbers
    390. 

  390.     {0x1D200, 0x1D24F, LANGUAGE_GREEK},             // Ancient Greek Musical
    391. 

  391.     {0x20000, 0x2A6DF, LANGUAGE_DEFAULT_CJK},       // CJK Unified Ideographs Extension B
    392. 

  392.     {0x2F800, 0x2FA1F, LANGUAGE_DEFAULT_CJK}        // CJK Compatibility Ideographs Supplement
    393. 

  393. };
    394. 

  394. 

  395. // get language matching to the missing char
    396. 

  396. LanguageType MapCharToLanguage( sal_UCS4 uChar )
    397. 

  397. {
    398. 

  398.     // entries marked with default-CJK get replaced with the prefered CJK language
    399. 

  399.     static bool bFirst = true;
    400. 

  400.     if( bFirst )
    401. 

  401.     {
    402. 

  402.         bFirst = false;
    403. 

  403. 

  404.         // use method suggested in #i97086# to determnine the systems default language
    405. 

  405.         // TODO: move into i18npool or sal/osl/w32/nlsupport.c
    406. 

  406.         LanguageType nDefaultLang = 0;
    407. 

  407.         HKEY hKey = NULL;
    408. 

  408.         LONG lResult = ::RegOpenKeyExA( HKEY_LOCAL_MACHINE,
    409. 

  409.             "SYSTEM\\CurrentControlSet\\Control\\Nls\\Language",
    410. 

  410.             0, KEY_QUERY_VALUE, &hKey );
    411. 

  411.         char aKeyValBuf[16];
    412. 

  412.         DWORD nKeyValSize = sizeof(aKeyValBuf);
    413. 

  413.         if( ERROR_SUCCESS == lResult )
    414. 

  414.             lResult = RegQueryValueExA( hKey, "Default", NULL, NULL, (LPBYTE)aKeyValBuf, &nKeyValSize );
    415. 

  415.         aKeyValBuf[ sizeof(aKeyValBuf)-1 ] = '\0';
    416. 

  416.         if( ERROR_SUCCESS == lResult )
    417. 

  417.             nDefaultLang = (LanguageType)rtl_str_toInt32( aKeyValBuf, 16 );
    418. 

  418. 

  419.         // TODO: use the default-CJK language selected in
    420. 

  420.         //  Tools->Options->LangSettings->Languages when it becomes available here
    421. 

  421.         if( !nDefaultLang )
    422. 

  422.             nDefaultLang = Application::GetSettings().GetUILanguageTag().getLanguageType();
    423. 

  423. 

  424.         LanguageType nDefaultCJK = MsLangId::isCJK(nDefaultLang) ? nDefaultLang : LANGUAGE_CHINESE;
    425. 

  425. 

  426.         // change the marked entries to prefered language
    427. 

  427.         static const int nCount = SAL_N_ELEMENTS(aLangFromCodeChart);
    428. 

  428.         for( int i = 0; i < nCount; ++i )
    429. 

  429.         {
    430. 

  430.             if( aLangFromCodeChart[ i].mnLangID == LANGUAGE_DEFAULT_CJK )
    431. 

  431.                 aLangFromCodeChart[ i].mnLangID = nDefaultCJK;
    432. 

  432.         }
    433. 

  433.     }
    434. 

  434. 

  435.     // binary search
    436. 

  436.     int nLow = 0;
    437. 

  437.     int nHigh = SAL_N_ELEMENTS(aLangFromCodeChart) - 1;
    438. 

  438.     while( nLow <= nHigh )
    439. 

  439.     {
    440. 

  440.         int nMiddle = (nHigh + nLow) / 2;
    441. 

  441.         if( uChar < aLangFromCodeChart[ nMiddle].mnMinCode )
    442. 

  442.             nHigh = nMiddle - 1;
    443. 

  443.         else if( uChar > aLangFromCodeChart[ nMiddle].mnMaxCode )
    444. 

  444.             nLow = nMiddle + 1;
    445. 

  445.         else
    446. 

  446.             return aLangFromCodeChart[ nMiddle].mnLangID;
    447. 

  447.     }
    448. 

  448. 

  449.     return LANGUAGE_DONTKNOW;
    450. 

  450. }
    451. 

  451. 

  452. class WinGlyphFallbackSubstititution
    453. 

  453. :    public ImplGlyphFallbackFontSubstitution
    454. 

  454. {
    455. 

  455. public:
    456. 

  456.     explicit    WinGlyphFallbackSubstititution( HDC );
    457. 

  457. 

  458.     bool FindFontSubstitute( FontSelectPattern&, rtl::OUString& rMissingChars ) const;
    459. 

  459. private:
    460. 

  460.     HDC mhDC;
    461. 

  461.     bool HasMissingChars( const PhysicalFontFace*, const rtl::OUString& rMissingChars ) const;
    462. 

  462. };
    463. 

  463. 

  464. inline WinGlyphFallbackSubstititution::WinGlyphFallbackSubstititution( HDC hDC )
    465. 

  465. :   mhDC( hDC )
    466. 

  466. {}
    467. 

  467. 

  468. void ImplGetLogFontFromFontSelect( HDC, const FontSelectPattern*,
    469. 

  469.     LOGFONTW&, bool /*bTestVerticalAvail*/ );
    470. 

  470. 

  471. // does a font face hold the given missing characters?
    472. 

  472. bool WinGlyphFallbackSubstititution::HasMissingChars( const PhysicalFontFace* pFace, const rtl::OUString& rMissingChars ) const
    473. 

  473. {
    474. 

  474.     const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFace);
    475. 

  475.     const ImplFontCharMap* pCharMap = pWinFont->GetImplFontCharMap();
    476. 

  476.     if( !pCharMap )
    477. 

  477.     {
    478. 

  478.         // construct a Size structure as the parameter of constructor of class FontSelectPattern
    479. 

  479.         const Size aSize( pFace->GetWidth(), pFace->GetHeight() );
    480. 

  480.         // create a FontSelectPattern object for getting s LOGFONT
    481. 

  481.         const FontSelectPattern aFSD( *pFace, aSize, (float)aSize.Height(), 0, false );
    482. 

  482.         // construct log font
    483. 

  483.         LOGFONTW aLogFont;
    484. 

  484.         ImplGetLogFontFromFontSelect( mhDC, &aFSD, aLogFont, true );
    485. 

  485. 

  486.         // create HFONT from log font
    487. 

  487.         HFONT hNewFont = ::CreateFontIndirectW( &aLogFont );
    488. 

  488.         // select the new font into device
    489. 

  489.         HFONT hOldFont = ::SelectFont( mhDC, hNewFont );
    490. 

  490. 

  491.         // read CMAP table to update their pCharMap
    492. 

  492.         pWinFont->UpdateFromHDC( mhDC );
    493. 

  493. 

  494.         // cleanup temporary font
    495. 

  495.         ::SelectFont( mhDC, hOldFont );
    496. 

  496.         ::DeleteFont( hNewFont );
    497. 

  497. 

  498.         // get the new charmap
    499. 

  499.         pCharMap = pWinFont->GetImplFontCharMap();
    500. 

  500.     }
    501. 

  501. 

  502.     // avoid fonts with unknown CMAP subtables for glyph fallback
    503. 

  503.     if( !pCharMap || pCharMap->IsDefaultMap() )
    504. 

  504.         return false;
    505. 

  505.         pCharMap->AddReference();
    506. 

  506. 

  507.     int nMatchCount = 0;
    508. 

  508.     // static const int nMaxMatchCount = 1; // TODO: tolerate more missing characters?
    509. 

  509.     const sal_Int32 nStrLen = rMissingChars.getLength();
    510. 

  510.     for( sal_Int32 nStrIdx = 0; nStrIdx < nStrLen; /* ++nStrIdx unreachable code, see the 'break' below */ )
    511. 

  511.     {
    512. 

  512.         const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
    513. 

  513.         nMatchCount += pCharMap->HasChar( uChar );
    514. 

  514.         break; // for now
    515. 

  515.     }
    516. 

  516.         pCharMap->DeReference();
    517. 

  517. 

  518.     const bool bHasMatches = (nMatchCount > 0);
    519. 

  519.     return bHasMatches;
    520. 

  520. }
    521. 

  521. 

  522. namespace
    523. 

  523. {
    524. 

  524.     //used by 2-level font fallback
    525. 

  525.     ImplDevFontListData* findDevFontListByLocale(const ImplDevFontList &rDevFontList,
    526. 

  526.         const com::sun::star::lang::Locale& rLocale )
    527. 

  527.     {
    528. 

  528.         // get the default font for a specified locale
    529. 

  529.         const utl::DefaultFontConfiguration& rDefaults =
    530. 

  530.             utl::DefaultFontConfiguration::get();
    531. 

  531.         const rtl::OUString aDefault = rDefaults.getUserInterfaceFont(rLocale);
    532. 

  532.         return rDevFontList.ImplFindByTokenNames(aDefault);
    533. 

  533.     }
    534. 

  534. }
    535. 

  535. 

  536. // find a fallback font for missing characters
    537. 

  537. // TODO: should stylistic matches be searched and prefered?
    538. 

  538. bool WinGlyphFallbackSubstititution::FindFontSubstitute( FontSelectPattern& rFontSelData, rtl::OUString& rMissingChars ) const
    539. 

  539. {
    540. 

  540.     // guess a locale matching to the missing chars
    541. 

  541.     com::sun::star::lang::Locale aLocale;
    542. 

  542.     LanguageType eLang = LANGUAGE_DONTKNOW;
    543. 

  543. 

  544.     sal_Int32 nStrIdx = 0;
    545. 

  545.     const sal_Int32 nStrLen = rMissingChars.getLength();
    546. 

  546.     while( nStrIdx < nStrLen )
    547. 

  547.     {
    548. 

  548.         const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
    549. 

  549.         eLang = MapCharToLanguage( uChar );
    550. 

  550.         if( eLang == LANGUAGE_DONTKNOW )
    551. 

  551.             continue;
    552. 

  552.         aLocale = LanguageTag( eLang ).getLocale();
    553. 

  553.         break;
    554. 

  554.     }
    555. 

  555. 

  556.     // fall back to default UI locale if the missing characters are inconclusive
    557. 

  557.     if( eLang == LANGUAGE_DONTKNOW )
    558. 

  558.         aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
    559. 

  559. 

  560.     // first level fallback:
    561. 

  561.     // try use the locale specific default fonts defined in VCL.xcu
    562. 

  562.     const ImplDevFontList* pDevFontList = ImplGetSVData()->maGDIData.mpScreenFontList;
    563. 

  563.     /*const*/ ImplDevFontListData* pDevFont = findDevFontListByLocale(*pDevFontList, aLocale);
    564. 

  564.     if( pDevFont )
    565. 

  565.     {
    566. 

  566.         const PhysicalFontFace* pFace = pDevFont->FindBestFontFace( rFontSelData );
    567. 

  567.         if( HasMissingChars( pFace, rMissingChars ) )
    568. 

  568.         {
    569. 

  569.             rFontSelData.maSearchName = pDevFont->GetSearchName();
    570. 

  570.             return true;
    571. 

  571.         }
    572. 

  572.     }
    573. 

  573. 

  574.     // are the missing characters symbols?
    575. 

  575.     pDevFont = pDevFontList->ImplFindByAttributes( IMPL_FONT_ATTR_SYMBOL,
    576. 

  576.                     rFontSelData.meWeight, rFontSelData.meWidthType,
    577. 

  577.                     rFontSelData.meItalic, rFontSelData.maSearchName );
    578. 

  578.     if( pDevFont )
    579. 

  579.     {
    580. 

  580.         const PhysicalFontFace* pFace = pDevFont->FindBestFontFace( rFontSelData );
    581. 

  581.         if( HasMissingChars( pFace, rMissingChars ) )
    582. 

  582.         {
    583. 

  583.             rFontSelData.maSearchName = pDevFont->GetSearchName();
    584. 

  584.             return true;
    585. 

  585.         }
    586. 

  586.     }
    587. 

  587. 

  588.     // last level fallback, check each font type face one by one
    589. 

  589.     const ImplGetDevFontList* pTestFontList = pDevFontList->GetDevFontList();
    590. 

  590.     // limit the count of fonts to be checked to prevent hangs
    591. 

  591.     static const int MAX_GFBFONT_COUNT = 600;
    592. 

  592.     int nTestFontCount = pTestFontList->Count();
    593. 

  593.     if( nTestFontCount > MAX_GFBFONT_COUNT )
    594. 

  594.         nTestFontCount = MAX_GFBFONT_COUNT;
    595. 

  595. 

  596.     for( int i = 0; i < nTestFontCount; ++i )
    597. 

  597.     {
    598. 

  598.         const PhysicalFontFace* pFace = pTestFontList->Get( i );
    599. 

  599.         if( !HasMissingChars( pFace, rMissingChars ) )
    600. 

  600.             continue;
    601. 

  601.         rFontSelData.maSearchName = pFace->maName;
    602. 

  602.         return true;
    603. 

  603.     }
    604. 

  604. 

  605.     return false;
    606. 

  606. }
    607. 

  607. 

  608. // =======================================================================
    609. 

  609. 

  610. struct ImplEnumInfo
    611. 

  611. {
    612. 

  612.     HDC                 mhDC;
    613. 

  613.     ImplDevFontList*    mpList;
    614. 

  614.     String*             mpName;
    615. 

  615.     LOGFONTA*           mpLogFontA;
    616. 

  616.     LOGFONTW*           mpLogFontW;
    617. 

  617.     UINT                mnPreferedCharSet;
    618. 

  618.     bool                mbCourier;
    619. 

  619.     bool                mbImplSalCourierScalable;
    620. 

  620.     bool                mbImplSalCourierNew;
    621. 

  621.     bool                mbPrinter;
    622. 

  622.     int                 mnFontCount;
    623. 

  623. };
    624. 

  624. 

  625. // =======================================================================
    626. 

  626. 

  627. static CharSet ImplCharSetToSal( BYTE nCharSet )
    628. 

  628. {
    629. 

  629.     rtl_TextEncoding eTextEncoding;
    630. 

  630. 

  631.     if ( nCharSet == OEM_CHARSET )
    632. 

  632.     {
    633. 

  633.         UINT nCP = (sal_uInt16)GetOEMCP();
    634. 

  634.         switch ( nCP )
    635. 

  635.         {
    636. 

  636.             // It is unclear why these two (undefined?) code page numbers are
    637. 

  637.             // handled specially here:
    638. 

  638.             case 1004:  eTextEncoding = RTL_TEXTENCODING_MS_1252; break;
    639. 

  639.             case 65400: eTextEncoding = RTL_TEXTENCODING_SYMBOL; break;
    640. 

  640.             default:
    641. 

  641.                 eTextEncoding = rtl_getTextEncodingFromWindowsCodePage(nCP);
    642. 

  642.                 break;
    643. 

  643.         };
    644. 

  644.     }
    645. 

  645.     else
    646. 

  646.     {
    647. 

  647.         if( nCharSet )
    648. 

  648.             eTextEncoding = rtl_getTextEncodingFromWindowsCharset( nCharSet );
    649. 

  649.         else
    650. 

  650.             eTextEncoding = RTL_TEXTENCODING_UNICODE;
    651. 

  651.     }
    652. 

  652. 

  653.     return eTextEncoding;
    654. 

  654. }
    655. 

  655. 

  656. // -----------------------------------------------------------------------
    657. 

  657. 

  658. static FontFamily ImplFamilyToSal( BYTE nFamily )
    659. 

  659. {
    660. 

  660.     switch ( nFamily & 0xF0 )
    661. 

  661.     {
    662. 

  662.         case FF_DECORATIVE:
    663. 

  663.             return FAMILY_DECORATIVE;
    664. 

  664. 

  665.         case FF_MODERN:
    666. 

  666.             return FAMILY_MODERN;
    667. 

  667. 

  668.         case FF_ROMAN:
    669. 

  669.             return FAMILY_ROMAN;
    670. 

  670. 

  671.         case FF_SCRIPT:
    672. 

  672.             return FAMILY_SCRIPT;
    673. 

  673. 

  674.         case FF_SWISS:
    675. 

  675.             return FAMILY_SWISS;
    676. 

  676. 

  677.         default:
    678. 

  678.             break;
    679. 

  679.     }
    680. 

  680. 

  681.     return FAMILY_DONTKNOW;
    682. 

  682. }
    683. 

  683. 

  684. // -----------------------------------------------------------------------
    685. 

  685. 

  686. static BYTE ImplFamilyToWin( FontFamily eFamily )
    687. 

  687. {
    688. 

  688.     switch ( eFamily )
    689. 

  689.     {
    690. 

  690.         case FAMILY_DECORATIVE:
    691. 

  691.             return FF_DECORATIVE;
    692. 

  692. 

  693.         case FAMILY_MODERN:
    694. 

  694.             return FF_MODERN;
    695. 

  695. 

  696.         case FAMILY_ROMAN:
    697. 

  697.             return FF_ROMAN;
    698. 

  698. 

  699.         case FAMILY_SCRIPT:
    700. 

  700.             return FF_SCRIPT;
    701. 

  701. 

  702.         case FAMILY_SWISS:
    703. 

  703.             return FF_SWISS;
    704. 

  704. 

  705.         case FAMILY_SYSTEM:
    706. 

  706.             return FF_SWISS;
    707. 

  707. 

  708.         default:
    709. 

  709.             break;
    710. 

  710.     }
    711. 

  711. 

  712.     return FF_DONTCARE;
    713. 

  713. }
    714. 

  714. 

  715. // -----------------------------------------------------------------------
    716. 

  716. 

  717. static FontWeight ImplWeightToSal( int nWeight )
    718. 

  718. {
    719. 

  719.     if ( nWeight <= FW_THIN )
    720. 

  720.         return WEIGHT_THIN;
    721. 

  721.     else if ( nWeight <= FW_ULTRALIGHT )
    722. 

  722.         return WEIGHT_ULTRALIGHT;
    723. 

  723.     else if ( nWeight <= FW_LIGHT )
    724. 

  724.         return WEIGHT_LIGHT;
    725. 

  725.     else if ( nWeight < FW_MEDIUM )
    726. 

  726.         return WEIGHT_NORMAL;
    727. 

  727.     else if ( nWeight == FW_MEDIUM )
    728. 

  728.         return WEIGHT_MEDIUM;
    729. 

  729.     else if ( nWeight <= FW_SEMIBOLD )
    730. 

  730.         return WEIGHT_SEMIBOLD;
    731. 

  731.     else if ( nWeight <= FW_BOLD )
    732. 

  732.         return WEIGHT_BOLD;
    733. 

  733.     else if ( nWeight <= FW_ULTRABOLD )
    734. 

  734.         return WEIGHT_ULTRABOLD;
    735. 

  735.     else
    736. 

  736.         return WEIGHT_BLACK;
    737. 

  737. }
    738. 

  738. 

  739. // -----------------------------------------------------------------------
    740. 

  740. 

  741. static int ImplWeightToWin( FontWeight eWeight )
    742. 

  742. {
    743. 

  743.     switch ( eWeight )
    744. 

  744.     {
    745. 

  745.         case WEIGHT_THIN:
    746. 

  746.             return FW_THIN;
    747. 

  747. 

  748.         case WEIGHT_ULTRALIGHT:
    749. 

  749.             return FW_ULTRALIGHT;
    750. 

  750. 

  751.         case WEIGHT_LIGHT:
    752. 

  752.             return FW_LIGHT;
    753. 

  753. 

  754.         case WEIGHT_SEMILIGHT:
    755. 

  755.         case WEIGHT_NORMAL:
    756. 

  756.             return FW_NORMAL;
    757. 

  757. 

  758.         case WEIGHT_MEDIUM:
    759. 

  759.             return FW_MEDIUM;
    760. 

  760. 

  761.         case WEIGHT_SEMIBOLD:
    762. 

  762.             return FW_SEMIBOLD;
    763. 

  763. 

  764.         case WEIGHT_BOLD:
    765. 

  765.             return FW_BOLD;
    766. 

  766. 

  767.         case WEIGHT_ULTRABOLD:
    768. 

  768.             return FW_ULTRABOLD;
    769. 

  769. 

  770.         case WEIGHT_BLACK:
    771. 

  771.             return FW_BLACK;
    772. 

  772. 

  773.         default:
    774. 

  774.             break;
    775. 

  775.     }
    776. 

  776. 

  777.     return 0;
    778. 

  778. }
    779. 

  779. 

  780. // -----------------------------------------------------------------------
    781. 

  781. 

  782. inline FontPitch ImplLogPitchToSal( BYTE nPitch )
    783. 

  783. {
    784. 

  784.     if ( nPitch & FIXED_PITCH )
    785. 

  785.         return PITCH_FIXED;
    786. 

  786.     else
    787. 

  787.         return PITCH_VARIABLE;
    788. 

  788. }
    789. 

  789. 

  790. // -----------------------------------------------------------------------
    791. 

  791. 

  792. inline FontPitch ImplMetricPitchToSal( BYTE nPitch )
    793. 

  793. {
    794. 

  794.     // Sausaecke bei MS !! siehe NT Hilfe
    795. 

  795.     if ( !(nPitch & TMPF_FIXED_PITCH) )
    796. 

  796.         return PITCH_FIXED;
    797. 

  797.     else
    798. 

  798.         return PITCH_VARIABLE;
    799. 

  799. }
    800. 

  800. 

  801. // -----------------------------------------------------------------------
    802. 

  802. 

  803. inline BYTE ImplPitchToWin( FontPitch ePitch )
    804. 

  804. {
    805. 

  805.     if ( ePitch == PITCH_FIXED )
    806. 

  806.         return FIXED_PITCH;
    807. 

  807.     else if ( ePitch == PITCH_VARIABLE )
    808. 

  808.         return VARIABLE_PITCH;
    809. 

  809.     else
    810. 

  810.         return DEFAULT_PITCH;
    811. 

  811. }
    812. 

  812. 

  813. // -----------------------------------------------------------------------
    814. 

  814. 

  815. static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXA& rEnumFont,
    816. 

  816.     const NEWTEXTMETRICA& rMetric, DWORD nFontType )
    817. 

  817. {
    818. 

  818.     ImplDevFontAttributes aDFA;
    819. 

  819. 

  820.     const LOGFONTA rLogFont = rEnumFont.elfLogFont;
    821. 

  821. 

  822.     // get font face attributes
    823. 

  823.     aDFA.meFamily       = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
    824. 

  824.     aDFA.meWidthType    = WIDTH_DONTKNOW;
    825. 

  825.     aDFA.meWeight       = ImplWeightToSal( rLogFont.lfWeight );
    826. 

  826.     aDFA.meItalic       = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
    827. 

  827.     aDFA.mePitch        = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
    828. 

  828.     aDFA.mbSymbolFlag   = (rLogFont.lfCharSet == SYMBOL_CHARSET);
    829. 

  829. 

  830.     // get the font face name
    831. 

  831.     aDFA.maName = ImplSalGetUniString( rLogFont.lfFaceName );
    832. 

  832. 

  833.     // use the face's style name only if it looks reasonable
    834. 

  834.     const char* pStyleName = (const char*)rEnumFont.elfStyle;
    835. 

  835.     const char* pEnd = pStyleName + sizeof( rEnumFont.elfStyle );
    836. 

  836.     const char* p = pStyleName;
    837. 

  837.     for(; *p && (p < pEnd); ++p )
    838. 

  838.         if( (0x00 < *p) && (*p < 0x20) )
    839. 

  839.             break;
    840. 

  840.     if( p < pEnd )
    841. 

  841.         aDFA.maStyleName = ImplSalGetUniString( pStyleName );
    842. 

  842. 

  843.     // get device specific font attributes
    844. 

  844.     aDFA.mbOrientation  = (nFontType & RASTER_FONTTYPE) == 0;
    845. 

  845.     aDFA.mbDevice       = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    846. 

  846. 

  847.     aDFA.mbEmbeddable   = false;
    848. 

  848.     aDFA.mbSubsettable  = false;
    849. 

  849.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
    850. 

  850.      || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
    851. 

  851.         aDFA.mbSubsettable = true;
    852. 

  852.     else if( 0 != (rMetric.ntmFlags & NTM_TYPE1) ) // TODO: implement subsetting for type1 too
    853. 

  853.         aDFA.mbEmbeddable = true;
    854. 

  854. 

  855.     // heuristics for font quality
    856. 

  856.     // -   standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
    857. 

  857.     // -   subsetting > embedding > none
    858. 

  858.     aDFA.mnQuality = 0;
    859. 

  859.     if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
    860. 

  860.         aDFA.mnQuality += 50;
    861. 

  861.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
    862. 

  862.         aDFA.mnQuality += 10;
    863. 

  863.     if( aDFA.mbSubsettable )
    864. 

  864.         aDFA.mnQuality += 200;
    865. 

  865.     else if( aDFA.mbEmbeddable )
    866. 

  866.         aDFA.mnQuality += 100;
    867. 

  867. 

  868.     // #i38665# prefer Type1 versions of the standard postscript fonts
    869. 

  869.     if( aDFA.mbEmbeddable )
    870. 

  870.     {
    871. 

  871.         if( aDFA.maName.EqualsAscii( "AvantGarde" )
    872. 

  872.         ||  aDFA.maName.EqualsAscii( "Bookman" )
    873. 

  873.         ||  aDFA.maName.EqualsAscii( "Courier" )
    874. 

  874.         ||  aDFA.maName.EqualsAscii( "Helvetica" )
    875. 

  875.         ||  aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
    876. 

  876.         ||  aDFA.maName.EqualsAscii( "Palatino" )
    877. 

  877.         ||  aDFA.maName.EqualsAscii( "Symbol" )
    878. 

  878.         ||  aDFA.maName.EqualsAscii( "Times" )
    879. 

  879.         ||  aDFA.maName.EqualsAscii( "ZapfChancery" )
    880. 

  880.         ||  aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
    881. 

  881.             aDFA.mnQuality += 500;
    882. 

  882.     }
    883. 

  883. 

  884.     // TODO: add alias names
    885. 

  885.     return aDFA;
    886. 

  886. }
    887. 

  887. 

  888. // -----------------------------------------------------------------------
    889. 

  889. 

  890. static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXW& rEnumFont,
    891. 

  891.     const NEWTEXTMETRICW& rMetric, DWORD nFontType )
    892. 

  892. {
    893. 

  893.     ImplDevFontAttributes aDFA;
    894. 

  894. 

  895.     const LOGFONTW rLogFont = rEnumFont.elfLogFont;
    896. 

  896. 

  897.     // get font face attributes
    898. 

  898.     aDFA.meFamily       = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
    899. 

  899.     aDFA.meWidthType    = WIDTH_DONTKNOW;
    900. 

  900.     aDFA.meWeight       = ImplWeightToSal( rLogFont.lfWeight );
    901. 

  901.     aDFA.meItalic       = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
    902. 

  902.     aDFA.mePitch        = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
    903. 

  903.     aDFA.mbSymbolFlag   = (rLogFont.lfCharSet == SYMBOL_CHARSET);
    904. 

  904. 

  905.     // get the font face name
    906. 

  906.     aDFA.maName = reinterpret_cast<const sal_Unicode*>(rLogFont.lfFaceName);
    907. 

  907. 

  908.     // use the face's style name only if it looks reasonable
    909. 

  909.     const wchar_t* pStyleName = rEnumFont.elfStyle;
    910. 

  910.     const wchar_t* pEnd = pStyleName + sizeof(rEnumFont.elfStyle)/sizeof(*rEnumFont.elfStyle);
    911. 

  911.     const wchar_t* p = pStyleName;
    912. 

  912.     for(; *p && (p < pEnd); ++p )
    913. 

  913.         if( *p < 0x0020 )
    914. 

  914.             break;
    915. 

  915.     if( p < pEnd )
    916. 

  916.         aDFA.maStyleName = reinterpret_cast<const sal_Unicode*>(pStyleName);
    917. 

  917. 

  918.     // get device specific font attributes
    919. 

  919.     aDFA.mbOrientation  = (nFontType & RASTER_FONTTYPE) == 0;
    920. 

  920.     aDFA.mbDevice       = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    921. 

  921. 

  922.     aDFA.mbEmbeddable   = false;
    923. 

  923.     aDFA.mbSubsettable  = false;
    924. 

  924.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
    925. 

  925.      || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
    926. 

  926.         aDFA.mbSubsettable = true;
    927. 

  927.     else if( 0 != (rMetric.ntmFlags & NTM_TYPE1) ) // TODO: implement subsetting for type1 too
    928. 

  928.         aDFA.mbEmbeddable = true;
    929. 

  929. 

  930.     // heuristics for font quality
    931. 

  931.     // -   standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
    932. 

  932.     // -   subsetting > embedding > none
    933. 

  933.     aDFA.mnQuality = 0;
    934. 

  934.     if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
    935. 

  935.         aDFA.mnQuality += 50;
    936. 

  936.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
    937. 

  937.         aDFA.mnQuality += 10;
    938. 

  938.     if( aDFA.mbSubsettable )
    939. 

  939.         aDFA.mnQuality += 200;
    940. 

  940.     else if( aDFA.mbEmbeddable )
    941. 

  941.         aDFA.mnQuality += 100;
    942. 

  942. 

  943.     // #i38665# prefer Type1 versions of the standard postscript fonts
    944. 

  944.     if( aDFA.mbEmbeddable )
    945. 

  945.     {
    946. 

  946.         if( aDFA.maName.EqualsAscii( "AvantGarde" )
    947. 

  947.         ||  aDFA.maName.EqualsAscii( "Bookman" )
    948. 

  948.         ||  aDFA.maName.EqualsAscii( "Courier" )
    949. 

  949.         ||  aDFA.maName.EqualsAscii( "Helvetica" )
    950. 

  950.         ||  aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
    951. 

  951.         ||  aDFA.maName.EqualsAscii( "Palatino" )
    952. 

  952.         ||  aDFA.maName.EqualsAscii( "Symbol" )
    953. 

  953.         ||  aDFA.maName.EqualsAscii( "Times" )
    954. 

  954.         ||  aDFA.maName.EqualsAscii( "ZapfChancery" )
    955. 

  955.         ||  aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
    956. 

  956.             aDFA.mnQuality += 500;
    957. 

  957.     }
    958. 

  958. 

  959.     // TODO: add alias names
    960. 

  960.     return aDFA;
    961. 

  961. }
    962. 

  962. 

  963. // -----------------------------------------------------------------------
    964. 

  964. 

  965. static ImplWinFontData* ImplLogMetricToDevFontDataA( const ENUMLOGFONTEXA* pLogFont,
    966. 

  966.                                          const NEWTEXTMETRICA* pMetric,
    967. 

  967.                                          DWORD nFontType )
    968. 

  968. {
    969. 

  969.     int nHeight = 0;
    970. 

  970.     if ( nFontType & RASTER_FONTTYPE )
    971. 

  971.         nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
    972. 

  972. 

  973.     ImplWinFontData* pData = new ImplWinFontData(
    974. 

  974.         WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
    975. 

  975.         nHeight,
    976. 

  976.         pLogFont->elfLogFont.lfCharSet,
    977. 

  977.         pMetric->tmPitchAndFamily );
    978. 

  978. 

  979.     return pData;
    980. 

  980. }
    981. 

  981. 

  982. // -----------------------------------------------------------------------
    983. 

  983. 

  984. static ImplWinFontData* ImplLogMetricToDevFontDataW( const ENUMLOGFONTEXW* pLogFont,
    985. 

  985.                                          const NEWTEXTMETRICW* pMetric,
    986. 

  986.                                          DWORD nFontType )
    987. 

  987. {
    988. 

  988.     int nHeight = 0;
    989. 

  989.     if ( nFontType & RASTER_FONTTYPE )
    990. 

  990.         nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
    991. 

  991. 

  992.     ImplWinFontData* pData = new ImplWinFontData(
    993. 

  993.         WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
    994. 

  994.         nHeight,
    995. 

  995.         pLogFont->elfLogFont.lfCharSet,
    996. 

  996.         pMetric->tmPitchAndFamily );
    997. 

  997. 

  998.     return pData;
    999. 

  999. }
    1000. 

  1000. 

  1001. // -----------------------------------------------------------------------
    1002. 

  1002. 

  1003. void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
    1004. 

  1004. {
    1005. 

  1005.     rtl::OUString aFontName( reinterpret_cast<const sal_Unicode*>(rLogFont.lfFaceName) );
    1006. 

  1006.     if (!aFontName.isEmpty())
    1007. 

  1007.     {
    1008. 

  1008.         rFont.SetName( aFontName );
    1009. 

  1009.         rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
    1010. 

  1010.         rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
    1011. 

  1011.         rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
    1012. 

  1012.         rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
    1013. 

  1013. 

  1014.         long nFontHeight = rLogFont.lfHeight;
    1015. 

  1015.         if ( nFontHeight < 0 )
    1016. 

  1016.             nFontHeight = -nFontHeight;
    1017. 

  1017.         long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
    1018. 

  1018.         if( !nDPIY )
    1019. 

  1019.             nDPIY = 600;
    1020. 

  1020.         nFontHeight *= 72;
    1021. 

  1021.         nFontHeight += nDPIY/2;
    1022. 

  1022.         nFontHeight /= nDPIY;
    1023. 

  1023.         rFont.SetSize( Size( 0, nFontHeight ) );
    1024. 

  1024.         rFont.SetOrientation( (short)rLogFont.lfEscapement );
    1025. 

  1025.         if ( rLogFont.lfItalic )
    1026. 

  1026.             rFont.SetItalic( ITALIC_NORMAL );
    1027. 

  1027.         else
    1028. 

  1028.             rFont.SetItalic( ITALIC_NONE );
    1029. 

  1029.         if ( rLogFont.lfUnderline )
    1030. 

  1030.             rFont.SetUnderline( UNDERLINE_SINGLE );
    1031. 

  1031.         else
    1032. 

  1032.             rFont.SetUnderline( UNDERLINE_NONE );
    1033. 

  1033.         if ( rLogFont.lfStrikeOut )
    1034. 

  1034.             rFont.SetStrikeout( STRIKEOUT_SINGLE );
    1035. 

  1035.         else
    1036. 

  1036.             rFont.SetStrikeout( STRIKEOUT_NONE );
    1037. 

  1037.     }
    1038. 

  1038. }
    1039. 

  1039. 

  1040. // =======================================================================
    1041. 

  1041. #ifdef ENABLE_GRAPHITE
    1042. 

  1042. 

  1043. #ifdef DEBUG
    1044. 

  1044. static FILE * grLogFile = NULL;
    1045. 

  1045. static FILE * grLog()
    1046. 

  1046. {
    1047. 

  1047.     std::string logFileName(getenv("TEMP"));
    1048. 

  1048.     logFileName.append("\\grface.log");
    1049. 

  1049.     if (grLogFile == NULL) grLogFile = fopen(logFileName.c_str(),"w");
    1050. 

  1050.     else fflush(grLogFile);
    1051. 

  1051.     return grLogFile;
    1052. 

  1052. }
    1053. 

  1053. #undef NDEBUG
    1054. 

  1054. #endif
    1055. 

  1055. 

  1056. const void * getGrTable(const void* appFaceHandle, unsigned int name, size_t *len)
    1057. 

  1057. {
    1058. 

  1058.     const GrFontData * fontTables = reinterpret_cast<const GrFontData*>(appFaceHandle);
    1059. 

  1059.     return fontTables->getTable(name, len);
    1060. 

  1060. }
    1061. 

  1061. 

  1062. GrFontData::GrFontData(HDC hDC) :
    1063. 

  1063.     mhDC(hDC), mpFace(NULL), mnRefCount(1)
    1064. 

  1064. {
    1065. 

  1065.     // The face options ensure that the tables are all read at construction
    1066. 

  1066.     // time so there is no need to keep the hDC uptodate
    1067. 

  1067.     static const char* pGraphiteCacheStr = getenv( "SAL_GRAPHITE_CACHE_SIZE" );
    1068. 

  1068.     unsigned long graphiteSegCacheSize = pGraphiteCacheStr ? (atoi(pGraphiteCacheStr)) : 0;
    1069. 

  1069.     if (graphiteSegCacheSize > 500)
    1070. 

  1070.         mpFace = gr_make_face_with_seg_cache(this, getGrTable,
    1071. 

  1071.             graphiteSegCacheSize, gr_face_preloadGlyphs | gr_face_cacheCmap);
    1072. 

  1072.     else
    1073. 

  1073.         mpFace = gr_make_face(this, getGrTable,
    1074. 

  1074.             gr_face_preloadGlyphs | gr_face_cacheCmap);
    1075. 

  1075. #ifdef DEBUG
    1076. 

  1076.         fprintf(grLog(), "gr_make_face %lx for WinFontData %lx\n", (unsigned long)mpFace,
    1077. 

  1077.             (unsigned long)this);
    1078. 

  1078. #endif
    1079. 

  1079.     mhDC = NULL;
    1080. 

  1080. }
    1081. 

  1081. 

  1082. GrFontData::~GrFontData()
    1083. 

  1083. {
    1084. 

  1084.     if (mpFace)
    1085. 

  1085.     {
    1086. 

  1086. #ifdef DEBUG
    1087. 

  1087.         fprintf(grLog(), "gr_face_destroy %lx for WinFontData %lx\n", (unsigned long)mpFace,
    1088. 

  1088.             (unsigned long)this);
    1089. 

  1089. #endif
    1090. 

  1090.         gr_face_destroy(mpFace);
    1091. 

  1091.         mpFace = NULL;
    1092. 

  1092.     }
    1093. 

  1093.     std::vector<RawFontData*>::iterator i = mvData.begin();
    1094. 

  1094.     while (i != mvData.end())
    1095. 

  1095.     {
    1096. 

  1096.         delete *i;
    1097. 

  1097.         ++i;
    1098. 

  1098.     }
    1099. 

  1099.     mvData.clear();
    1100. 

  1100. }
    1101. 

  1101. 

  1102. const void * GrFontData::getTable(unsigned int name, size_t *len) const
    1103. 

  1103. {
    1104. 

  1104. #ifdef DEBUG
    1105. 

  1105. #undef NDEBUG
    1106. 

  1106. #endif
    1107. 

  1107.     assert(mhDC);
    1108. 

  1108.     // swap the bytes
    1109. 

  1109.     union TtfTag {
    1110. 

  1110.         unsigned int i;
    1111. 

  1111.         unsigned char c[4];
    1112. 

  1112.     };
    1113. 

  1113.     TtfTag littleEndianTag;
    1114. 

  1114.     littleEndianTag.i = name;
    1115. 

  1115.     TtfTag bigEndianTag;
    1116. 

  1116.     bigEndianTag.c[0] = littleEndianTag.c[3];
    1117. 

  1117.     bigEndianTag.c[1] = littleEndianTag.c[2];
    1118. 

  1118.     bigEndianTag.c[2] = littleEndianTag.c[1];
    1119. 

  1119.     bigEndianTag.c[3] = littleEndianTag.c[0];
    1120. 

  1120.     mvData.push_back(new RawFontData(mhDC, bigEndianTag.i));
    1121. 

  1121.     const RawFontData * data = mvData[mvData.size()-1];
    1122. 

  1122.     if (data && (data->size() > 0))
    1123. 

  1123.     {
    1124. 

  1124.         if (len)
    1125. 

  1125.             *len = data->size();
    1126. 

  1126.         return reinterpret_cast<const void *>(data->get());
    1127. 

  1127.     }
    1128. 

  1128.     else
    1129. 

  1129.     {
    1130. 

  1130.         if (len)
    1131. 

  1131.             *len = 0;
    1132. 

  1132.         return NULL;
    1133. 

  1133.     }
    1134. 

  1134. }
    1135. 

  1135. #endif
    1136. 

  1136. 

  1137. ImplWinFontData::ImplWinFontData( const ImplDevFontAttributes& rDFS,
    1138. 

  1138.     int nHeight, BYTE eWinCharSet, BYTE nPitchAndFamily )
    1139. 

  1139. :   PhysicalFontFace( rDFS, 0 ),
    1140. 

  1140.     mnId( 0 ),
    1141. 

  1141.     mbDisableGlyphApi( false ),
    1142. 

  1142.     mbHasKoreanRange( false ),
    1143. 

  1143.     mbHasCJKSupport( false ),
    1144. 

  1144. #ifdef ENABLE_GRAPHITE
    1145. 

  1145.     mpGraphiteData(NULL),
    1146. 

  1146.     mbHasGraphiteSupport( false ),
    1147. 

  1147. #endif
    1148. 

  1148.     mbHasArabicSupport ( false ),
    1149. 

  1149.     mbFontCapabilitiesRead( false ),
    1150. 

  1150.     mpUnicodeMap( NULL ),
    1151. 

  1151.     mpEncodingVector( NULL ),
    1152. 

  1152.     mpFontCharSets( NULL ),
    1153. 

  1153.     mnFontCharSetCount( 0 ),
    1154. 

  1154.     meWinCharSet( eWinCharSet ),
    1155. 

  1155.     mnPitchAndFamily( nPitchAndFamily ),
    1156. 

  1156.     mbAliasSymbolsHigh( false ),
    1157. 

  1157.     mbAliasSymbolsLow( false ),
    1158. 

  1158.     mbGsubRead( false )
    1159. 

  1159. {
    1160. 

  1160.     SetBitmapSize( 0, nHeight );
    1161. 

  1161. 

  1162.     if( eWinCharSet == SYMBOL_CHARSET )
    1163. 

  1163.     {
    1164. 

  1164.         if( (nPitchAndFamily & TMPF_TRUETYPE) != 0 )
    1165. 

  1165.         {
    1166. 

  1166.             // truetype fonts need their symbols as U+F0xx
    1167. 

  1167.             mbAliasSymbolsHigh = true;
    1168. 

  1168.         }
    1169. 

  1169.         else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_DEVICE))
    1170. 

  1170.                                  == (TMPF_VECTOR|TMPF_DEVICE) )
    1171. 

  1171.         {
    1172. 

  1172.             // scalable device fonts (e.g. builtin printer fonts)
    1173. 

  1173.             // need their symbols as U+00xx
    1174. 

  1174.             mbAliasSymbolsLow  = true;
    1175. 

  1175.         }
    1176. 

  1176.         else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) == 0 )
    1177. 

  1177.         {
    1178. 

  1178.             // bitmap fonts need their symbols as U+F0xx
    1179. 

  1179.             mbAliasSymbolsHigh = true;
    1180. 

  1180.         }
    1181. 

  1181.     }
    1182. 

  1182. #ifdef DEBUG
    1183. 

  1183.     fprintf(grLog(), "ImplWinFontData::ImplWinFontData() %lx\n", (unsigned long)this);
    1184. 

  1184. #endif
    1185. 

  1185. }
    1186. 

  1186. 

  1187. // -----------------------------------------------------------------------
    1188. 

  1188. 

  1189. ImplWinFontData::~ImplWinFontData()
    1190. 

  1190. {
    1191. 

  1191.     delete[] mpFontCharSets;
    1192. 

  1192. 

  1193.     if( mpUnicodeMap )
    1194. 

  1194.         mpUnicodeMap->DeReference();
    1195. 

  1195. #ifdef ENABLE_GRAPHITE
    1196. 

  1196.     if (mpGraphiteData)
    1197. 

  1197.         mpGraphiteData->DeReference();
    1198. 

  1198. #ifdef DEBUG
    1199. 

  1199.     fprintf(grLog(), "ImplWinFontData::~ImplWinFontData %lx\n", (unsigned long)this);
    1200. 

  1200. #endif
    1201. 

  1201. #endif // ENABLE_GRAPHITE
    1202. 

  1202.     delete mpEncodingVector;
    1203. 

  1203. }
    1204. 

  1204. 

  1205. // -----------------------------------------------------------------------
    1206. 

  1206. 

  1207. sal_IntPtr ImplWinFontData::GetFontId() const
    1208. 

  1208. {
    1209. 

  1209.     return mnId;
    1210. 

  1210. }
    1211. 

  1211. 

  1212. // -----------------------------------------------------------------------
    1213. 

  1213. 

  1214. static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);}
    1215. 

  1215. static inline DWORD CalcTag( const char p[4]) { return (p[0]+(p[1]<<8)+(p[2]<<16)+(p[3]<<24)); }
    1216. 

  1216. 

  1217. // -----------------------------------------------------------------------
    1218. 

  1218. 

  1219. void ImplWinFontData::UpdateFromHDC( HDC hDC ) const
    1220. 

  1220. {
    1221. 

  1221.     // short circuit if already initialized
    1222. 

  1222.     if( mpUnicodeMap != NULL )
    1223. 

  1223.         return;
    1224. 

  1224. 

  1225.     ReadCmapTable( hDC );
    1226. 

  1226.     GetFontCapabilities( hDC );
    1227. 

  1227. #ifdef ENABLE_GRAPHITE
    1228. 

  1228.     static const char* pDisableGraphiteText = getenv( "SAL_DISABLE_GRAPHITE" );
    1229. 

  1229.     if( !pDisableGraphiteText || (pDisableGraphiteText[0] == '0') )
    1230. 

  1230.     {
    1231. 

  1231.         const DWORD nSilfTag = CalcTag("Silf");
    1232. 

  1232.         const RawFontData aRawFontData( hDC, nSilfTag );
    1233. 

  1233.         mbHasGraphiteSupport = (aRawFontData.size() > 0);
    1234. 

  1234.         if (mbHasGraphiteSupport)
    1235. 

  1235.         {
    1236. 

  1236. #ifdef DEBUG
    1237. 

  1237.             fprintf(grLog(), "ImplWinFontData::UpdateFromHDC %lx\n",
    1238. 

  1238.             (unsigned long)this);
    1239. 

  1239. #endif
    1240. 

  1240.             if (mpGraphiteData == NULL)
    1241. 

  1241.             {
    1242. 

  1242.                 mpGraphiteData = new GrFontData(hDC);
    1243. 

  1243.                 if (!mpGraphiteData->getFace())
    1244. 

  1244.                 {
    1245. 

  1245.                     mbHasGraphiteSupport = false;
    1246. 

  1246.                     delete mpGraphiteData;
    1247. 

  1247.                     mpGraphiteData = NULL;
    1248. 

  1248.                 }
    1249. 

  1249.             }
    1250. 

  1250.         }
    1251. 

  1251.     }
    1252. 

  1252. #endif
    1253. 

  1253. 

  1254.     // even if the font works some fonts have problems with the glyph API
    1255. 

  1255.     // => the heuristic below tries to figure out which fonts have the problem
    1256. 

  1256.     TEXTMETRICA aTextMetric;
    1257. 

  1257.     if( ::GetTextMetricsA( hDC, &aTextMetric ) )
    1258. 

  1258.         if( !(aTextMetric.tmPitchAndFamily & TMPF_TRUETYPE)
    1259. 

  1259.         ||   (aTextMetric.tmPitchAndFamily & TMPF_DEVICE) )
    1260. 

  1260.             mbDisableGlyphApi = true;
    1261. 

  1261. 

  1262. }
    1263. 

  1263. 

  1264. #ifdef ENABLE_GRAPHITE
    1265. 

  1265. const gr_face* ImplWinFontData::GraphiteFace() const
    1266. 

  1266. {
    1267. 

  1267. #ifdef DEBUG
    1268. 

  1268.     fprintf(grLog(), "ImplWinFontData::GraphiteFace %lx has face %lx\n",
    1269. 

  1269.         (unsigned long)this, mpGraphiteData? mpGraphiteData->getFace(): 0);
    1270. 

  1270. #endif
    1271. 

  1271.     return (mpGraphiteData)? mpGraphiteData->getFace() : NULL;
    1272. 

  1272. }
    1273. 

  1273. #endif
    1274. 

  1274. // -----------------------------------------------------------------------
    1275. 

  1275. 

  1276. bool ImplWinFontData::HasGSUBstitutions( HDC hDC ) const
    1277. 

  1277. {
    1278. 

  1278.     if( !mbGsubRead )
    1279. 

  1279.         ReadGsubTable( hDC );
    1280. 

  1280.     return !maGsubTable.empty();
    1281. 

  1281. }
    1282. 

  1282. 

  1283. // -----------------------------------------------------------------------
    1284. 

  1284. 

  1285. bool ImplWinFontData::IsGSUBstituted( sal_UCS4 cChar ) const
    1286. 

  1286. {
    1287. 

  1287.     return( maGsubTable.find( cChar ) != maGsubTable.end() );
    1288. 

  1288. }
    1289. 

  1289. 

  1290. // -----------------------------------------------------------------------
    1291. 

  1291. 

  1292. const ImplFontCharMap* ImplWinFontData::GetImplFontCharMap() const
    1293. 

  1293. {
    1294. 

  1294.     if( !mpUnicodeMap )
    1295. 

  1295.         return NULL;
    1296. 

  1296.     return mpUnicodeMap;
    1297. 

  1297. }
    1298. 

  1298. 

  1299. bool ImplWinFontData::GetImplFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
    1300. 

  1300. {
    1301. 

  1301.     rFontCapabilities = maFontCapabilities;
    1302. 

  1302.     return !rFontCapabilities.maUnicodeRange.empty() || !rFontCapabilities.maCodePageRange.empty();
    1303. 

  1303. }
    1304. 

  1304. 

  1305. // -----------------------------------------------------------------------
    1306. 

  1306. 

  1307. void ImplWinFontData::ReadGsubTable( HDC hDC ) const
    1308. 

  1308. {
    1309. 

  1309.     mbGsubRead = true;
    1310. 

  1310. 

  1311.     // check the existence of a GSUB table
    1312. 

  1312.     const DWORD GsubTag = CalcTag( "GSUB" );
    1313. 

  1313.     DWORD nRC = ::GetFontData( hDC, GsubTag, 0, NULL, 0 );
    1314. 

  1314.     if( (nRC == GDI_ERROR) || !nRC )
    1315. 

  1315.         return;
    1316. 

  1316. 

  1317.     // parse the GSUB table through sft
    1318. 

  1318.     // TODO: parse it directly
    1319. 

  1319. 

  1320.     // sft needs the full font file data => get it
    1321. 

  1321.     const RawFontData aRawFontData( hDC );
    1322. 

  1322.     if( !aRawFontData.get() )
    1323. 

  1323.         return;
    1324. 

  1324. 

  1325.     // open font file
    1326. 

  1326.     sal_uInt32 nFaceNum = 0;
    1327. 

  1327.     if( !*aRawFontData.get() )  // TTC candidate
    1328. 

  1328.         nFaceNum = ~0U;  // indicate "TTC font extracts only"
    1329. 

  1329. 

  1330.     TrueTypeFont* pTTFont = NULL;
    1331. 

  1331.     ::OpenTTFontBuffer( (void*)aRawFontData.get(), aRawFontData.size(), nFaceNum, &pTTFont );
    1332. 

  1332.     if( !pTTFont )
    1333. 

  1333.         return;
    1334. 

  1334. 

  1335.     // add vertically substituted characters to list
    1336. 

  1336.     static const sal_Unicode aGSUBCandidates[] = {
    1337. 

  1337.         0x0020, 0x0080, // ASCII
    1338. 

  1338.         0x2000, 0x2600, // misc
    1339. 

  1339.         0x3000, 0x3100, // CJK punctutation
    1340. 

  1340.         0x3300, 0x3400, // squared words
    1341. 

  1341.         0xFF00, 0xFFF0, // halfwidth|fullwidth forms
    1342. 

  1342.     0 };
    1343. 

  1343. 

  1344.     for( const sal_Unicode* pPair = aGSUBCandidates; *pPair; pPair += 2 )
    1345. 

  1345.         for( sal_Unicode cChar = pPair[0]; cChar < pPair[1]; ++cChar )
    1346. 

  1346.             if( ::MapChar( pTTFont, cChar, 0 ) != ::MapChar( pTTFont, cChar, 1 ) )
    1347. 

  1347.                 maGsubTable.insert( cChar ); // insert GSUBbed unicodes
    1348. 

  1348. 

  1349.     CloseTTFont( pTTFont );
    1350. 

  1350. }
    1351. 

  1351. 

  1352. // -----------------------------------------------------------------------
    1353. 

  1353. 

  1354. void ImplWinFontData::ReadCmapTable( HDC hDC ) const
    1355. 

  1355. {
    1356. 

  1356.     if( mpUnicodeMap != NULL )
    1357. 

  1357.         return;
    1358. 

  1358. 

  1359.     bool bIsSymbolFont = (meWinCharSet == SYMBOL_CHARSET);
    1360. 

  1360.     // get the CMAP table from the font which is selected into the DC
    1361. 

  1361.     const DWORD nCmapTag = CalcTag( "cmap" );
    1362. 

  1362.     const RawFontData aRawFontData( hDC, nCmapTag );
    1363. 

  1363.     // parse the CMAP table if available
    1364. 

  1364.     if( aRawFontData.get() ) {
    1365. 

  1365.         CmapResult aResult;
    1366. 

  1366.         ParseCMAP( aRawFontData.get(), aRawFontData.size(), aResult );
    1367. 

  1367.         mbDisableGlyphApi |= aResult.mbRecoded;
    1368. 

  1368.         aResult.mbSymbolic = bIsSymbolFont;
    1369. 

  1369.         if( aResult.mnRangeCount > 0 )
    1370. 

  1370.             mpUnicodeMap = new ImplFontCharMap( aResult );
    1371. 

  1371.     }
    1372. 

  1372. 

  1373.     if( !mpUnicodeMap )
    1374. 

  1374.         mpUnicodeMap = ImplFontCharMap::GetDefaultMap( bIsSymbolFont );
    1375. 

  1375.     mpUnicodeMap->AddReference();
    1376. 

  1376. }
    1377. 

  1377. 

  1378. void ImplWinFontData::GetFontCapabilities( HDC hDC ) const
    1379. 

  1379. {
    1380. 

  1380.     // read this only once per font
    1381. 

  1381.     if( mbFontCapabilitiesRead )
    1382. 

  1382.         return;
    1383. 

  1383. 

  1384.     mbFontCapabilitiesRead = true;
    1385. 

  1385. 

  1386.     // GSUB table
    1387. 

  1387.     DWORD nLength;
    1388. 

  1388.     const DWORD GsubTag = CalcTag( "GSUB" );
    1389. 

  1389.     nLength = ::GetFontData( hDC, GsubTag, 0, NULL, 0 );
    1390. 

  1390.     if( (nLength != GDI_ERROR) && nLength )
    1391. 

  1391.     {
    1392. 

  1392.         std::vector<unsigned char> aTable( nLength );
    1393. 

  1393.         unsigned char* pTable = &aTable[0];
    1394. 

  1394.         ::GetFontData( hDC, GsubTag, 0, pTable, nLength );
    1395. 

  1395.         vcl::getTTScripts(maFontCapabilities.maGSUBScriptTags, pTable, nLength);
    1396. 

  1396.     }
    1397. 

  1397. 

  1398.     // OS/2 table
    1399. 

  1399.     const DWORD OS2Tag = CalcTag( "OS/2" );
    1400. 

  1400.     nLength = ::GetFontData( hDC, OS2Tag, 0, NULL, 0 );
    1401. 

  1401.     if( (nLength != GDI_ERROR) && nLength )
    1402. 

  1402.     {
    1403. 

  1403.         std::vector<unsigned char> aTable( nLength );
    1404. 

  1404.         unsigned char* pTable = &aTable[0];
    1405. 

  1405.         ::GetFontData( hDC, OS2Tag, 0, pTable, nLength );
    1406. 

  1406.         if (vcl::getTTCoverage(maFontCapabilities.maUnicodeRange, maFontCapabilities.maCodePageRange, pTable, nLength))
    1407. 

  1407.         {
    1408. 

  1408.             // Check for CJK capabilities of the current font
    1409. 

  1409.             // TODO, we have this info already from getTT, decode bits to
    1410. 

  1410.             // a readable dynamic_bitset
    1411. 

  1411.             sal_uInt32 ulUnicodeRange1 = GetUInt( pTable + 42 );
    1412. 

  1412.             sal_uInt32 ulUnicodeRange2 = GetUInt( pTable + 46 );
    1413. 

  1413. 

  1414.             mbHasCJKSupport = (ulUnicodeRange2 & 0x2DF00000);
    1415. 

  1415.             mbHasKoreanRange= (ulUnicodeRange1 & 0x10000000)
    1416. 

  1416.                             | (ulUnicodeRange2 & 0x01100000);
    1417. 

  1417.             mbHasArabicSupport = (ulUnicodeRange1 & 0x00002000);
    1418. 

  1418.         }
    1419. 

  1419.     }
    1420. 

  1420. }
    1421. 

  1421. 

  1422. // =======================================================================
    1423. 

  1423. 

  1424. void WinSalGraphics::SetTextColor( SalColor nSalColor )
    1425. 

  1425. {
    1426. 

  1426.     COLORREF aCol = PALETTERGB( SALCOLOR_RED( nSalColor ),
    1427. 

  1427.                                 SALCOLOR_GREEN( nSalColor ),
    1428. 

  1428.                                 SALCOLOR_BLUE( nSalColor ) );
    1429. 

  1429. 

  1430.     if( !mbPrinter &&
    1431. 

  1431.         GetSalData()->mhDitherPal &&
    1432. 

  1432.         ImplIsSysColorEntry( nSalColor ) )
    1433. 

  1433.     {
    1434. 

  1434.         aCol = PALRGB_TO_RGB( aCol );
    1435. 

  1435.     }
    1436. 

  1436. 

  1437.     ::SetTextColor( mhDC, aCol );
    1438. 

  1438. }
    1439. 

  1439. 

  1440. // -----------------------------------------------------------------------
    1441. 

  1441. 

  1442. int CALLBACK SalEnumQueryFontProcExW( const ENUMLOGFONTEXW*,
    1443. 

  1443.                                       const NEWTEXTMETRICEXW*,
    1444. 

  1444.                                       DWORD, LPARAM lParam )
    1445. 

  1445. {
    1446. 

  1446.     *((bool*)(void*)lParam) = true;
    1447. 

  1447.     return 0;
    1448. 

  1448. }
    1449. 

  1449. 

  1450. // -----------------------------------------------------------------------
    1451. 

  1451. 

  1452. void ImplGetLogFontFromFontSelect( HDC hDC,
    1453. 

  1453.                                    const FontSelectPattern* pFont,
    1454. 

  1454.                                    LOGFONTW& rLogFont,
    1455. 

  1455.                                    bool /*bTestVerticalAvail*/ )
    1456. 

  1456. {
    1457. 

  1457.     UniString   aName;
    1458. 

  1458.     if ( pFont->mpFontData )
    1459. 

  1459.         aName = pFont->mpFontData->maName;
    1460. 

  1460.     else
    1461. 

  1461.         aName = pFont->maName.GetToken( 0 );
    1462. 

  1462. 

  1463.     UINT nNameLen = aName.Len();
    1464. 

  1464.     if ( nNameLen > (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1 )
    1465. 

  1465.         nNameLen = (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1;
    1466. 

  1466.     memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen*sizeof( wchar_t ) );
    1467. 

  1467.     rLogFont.lfFaceName[nNameLen] = 0;
    1468. 

  1468. 

  1469.     if( !pFont->mpFontData )
    1470. 

  1470.     {
    1471. 

  1471.         rLogFont.lfCharSet = pFont->IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
    1472. 

  1472.         rLogFont.lfPitchAndFamily = ImplPitchToWin( pFont->mePitch )
    1473. 

  1473.                                   | ImplFamilyToWin( pFont->meFamily );
    1474. 

  1474.     }
    1475. 

  1475.     else
    1476. 

  1476.     {
    1477. 

  1477.         const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>( pFont->mpFontData );
    1478. 

  1478.         rLogFont.lfCharSet        = pWinFontData->GetCharSet();
    1479. 

  1479.         rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
    1480. 

  1480.     }
    1481. 

  1481. 

  1482.     rLogFont.lfWeight          = ImplWeightToWin( pFont->meWeight );
    1483. 

  1483.     rLogFont.lfHeight          = (LONG)-pFont->mnHeight;
    1484. 

  1484.     rLogFont.lfWidth           = (LONG)pFont->mnWidth;
    1485. 

  1485.     rLogFont.lfUnderline       = 0;
    1486. 

  1486.     rLogFont.lfStrikeOut       = 0;
    1487. 

  1487.     rLogFont.lfItalic          = (pFont->meItalic) != ITALIC_NONE;
    1488. 

  1488.     rLogFont.lfEscapement      = pFont->mnOrientation;
    1489. 

  1489.     rLogFont.lfOrientation     = rLogFont.lfEscapement;
    1490. 

  1490.     rLogFont.lfClipPrecision   = CLIP_DEFAULT_PRECIS;
    1491. 

  1491.     rLogFont.lfQuality         = DEFAULT_QUALITY;
    1492. 

  1492.     rLogFont.lfOutPrecision    = OUT_TT_PRECIS;
    1493. 

  1493.     if ( pFont->mnOrientation )
    1494. 

  1494.         rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
    1495. 

  1495. 

  1496.     // disable antialiasing if requested
    1497. 

  1497.     if ( pFont->mbNonAntialiased )
    1498. 

  1498.         rLogFont.lfQuality = NONANTIALIASED_QUALITY;
    1499. 

  1499. 

  1500.     // select vertical mode if requested and available
    1501. 

  1501.     if( pFont->mbVertical && nNameLen )
    1502. 

  1502.     {
    1503. 

  1503.         // vertical fonts start with an '@'
    1504. 

  1504.         memmove( &rLogFont.lfFaceName[1], &rLogFont.lfFaceName[0],
    1505. 

  1505.             sizeof(rLogFont.lfFaceName)-sizeof(rLogFont.lfFaceName[0]) );
    1506. 

  1506.         rLogFont.lfFaceName[0] = '@';
    1507. 

  1507. 

  1508.         // check availability of vertical mode for this font
    1509. 

  1509.         bool bAvailable = false;
    1510. 

  1510.         EnumFontFamiliesExW( hDC, &rLogFont, (FONTENUMPROCW)SalEnumQueryFontProcExW,
    1511. 

  1511.                          (LPARAM)&bAvailable, 0 );
    1512. 

  1512. 

  1513.         if( !bAvailable )
    1514. 

  1514.         {
    1515. 

  1515.             // restore non-vertical name if not vertical mode isn't available
    1516. 

  1516.             memcpy( &rLogFont.lfFaceName[0], aName.GetBuffer(), nNameLen*sizeof(wchar_t) );
    1517. 

  1517.             if( nNameLen < LF_FACESIZE )
    1518. 

  1518.                 rLogFont.lfFaceName[nNameLen] = '\0';
    1519. 

  1519.         }
    1520. 

  1520.     }
    1521. 

  1521. }
    1522. 

  1522. 

  1523. // -----------------------------------------------------------------------
    1524. 

  1524. 

  1525. HFONT WinSalGraphics::ImplDoSetFont( FontSelectPattern* i_pFont, float& o_rFontScale, HFONT& o_rOldFont )
    1526. 

  1526. {
    1527. 

  1527.     HFONT hNewFont = 0;
    1528. 

  1528. 

  1529.     HDC hdcScreen = 0;
    1530. 

  1530.     if( mbVirDev )
    1531. 

  1531.         // only required for virtual devices, see below for details
    1532. 

  1532.         hdcScreen = GetDC(0);
    1533. 

  1533. 

  1534.     LOGFONTW aLogFont;
    1535. 

  1535.     ImplGetLogFontFromFontSelect( mhDC, i_pFont, aLogFont, true );
    1536. 

  1536. 

  1537.     // on the display we prefer Courier New when Courier is a
    1538. 

  1538.     // bitmap only font and we need to stretch or rotate it
    1539. 

  1539.     if( mbScreen
    1540. 

  1540.     &&  (i_pFont->mnWidth != 0
    1541. 

  1541.       || i_pFont->mnOrientation != 0
    1542. 

  1542.       || i_pFont->mpFontData == NULL
    1543. 

  1543.       || (i_pFont->mpFontData->GetHeight() != i_pFont->mnHeight))
    1544. 

  1544.     && !bImplSalCourierScalable
    1545. 

  1545.     && bImplSalCourierNew
    1546. 

  1546.     && (ImplSalWICompareAscii( aLogFont.lfFaceName, "Courier" ) == 0) )
    1547. 

  1547.         lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
    1548. 

  1548. 

  1549.     // #i47675# limit font requests to MAXFONTHEIGHT
    1550. 

  1550.     // TODO: share MAXFONTHEIGHT font instance
    1551. 

  1551.     if( (-aLogFont.lfHeight <= MAXFONTHEIGHT)
    1552. 

  1552.     &&  (+aLogFont.lfWidth <= MAXFONTHEIGHT) )
    1553. 

  1553.     {
    1554. 

  1554.         o_rFontScale = 1.0;
    1555. 

  1555.     }
    1556. 

  1556.     else if( -aLogFont.lfHeight >= +aLogFont.lfWidth )
    1557. 

  1557.     {
    1558. 

  1558.         o_rFontScale = -aLogFont.lfHeight / (float)MAXFONTHEIGHT;
    1559. 

  1559.         aLogFont.lfHeight = -MAXFONTHEIGHT;
    1560. 

  1560.         aLogFont.lfWidth = FRound( aLogFont.lfWidth / o_rFontScale );
    1561. 

  1561.     }
    1562. 

  1562.     else // #i95867# also limit font widths
    1563. 

  1563.     {
    1564. 

  1564.         o_rFontScale = +aLogFont.lfWidth / (float)MAXFONTHEIGHT;
    1565. 

  1565.         aLogFont.lfWidth = +MAXFONTHEIGHT;
    1566. 

  1566.         aLogFont.lfHeight = FRound( aLogFont.lfHeight / o_rFontScale );
    1567. 

  1567.     }
    1568. 

  1568. 

  1569.     hNewFont = ::CreateFontIndirectW( &aLogFont );
    1570. 

  1570.     if( hdcScreen )
    1571. 

  1571.     {
    1572. 

  1572.         // select font into screen hdc first to get an antialiased font
    1573. 

  1573.         // see knowledge base article 305290:
    1574. 

  1574.         // "PRB: Fonts Not Drawn Antialiased on Device Context for DirectDraw Surface"
    1575. 

  1575.         SelectFont( hdcScreen, SelectFont( hdcScreen , hNewFont ) );
    1576. 

  1576.     }
    1577. 

  1577.     o_rOldFont = ::SelectFont( mhDC, hNewFont );
    1578. 

  1578. 

  1579.     TEXTMETRICW aTextMetricW;
    1580. 

  1580.     if( !::GetTextMetricsW( mhDC, &aTextMetricW ) )
    1581. 

  1581.     {
    1582. 

  1582.         // the selected font doesn't work => try a replacement
    1583. 

  1583.         // TODO: use its font fallback instead
    1584. 

  1584.         lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
    1585. 

  1585.         aLogFont.lfPitchAndFamily = FIXED_PITCH;
    1586. 

  1586.         HFONT hNewFont2 = CreateFontIndirectW( &aLogFont );
    1587. 

  1587.         SelectFont( mhDC, hNewFont2 );
    1588. 

  1588.         DeleteFont( hNewFont );
    1589. 

  1589.         hNewFont = hNewFont2;
    1590. 

  1590.     }
    1591. 

  1591. 

  1592.     if( hdcScreen )
    1593. 

  1593.         ::ReleaseDC( NULL, hdcScreen );
    1594. 

  1594. 

  1595.     return hNewFont;
    1596. 

  1596. }
    1597. 

  1597. 

  1598. sal_uInt16 WinSalGraphics::SetFont( FontSelectPattern* pFont, int nFallbackLevel )
    1599. 

  1599. {
    1600. 

  1600.     // return early if there is no new font
    1601. 

  1601.     if( !pFont )
    1602. 

  1602.     {
    1603. 

  1603.         // deselect still active font
    1604. 

  1604.         if( mhDefFont )
    1605. 

  1605.             ::SelectFont( mhDC, mhDefFont );
    1606. 

  1606.         mfCurrentFontScale = mfFontScale[nFallbackLevel];
    1607. 

  1607.         // release no longer referenced font handles
    1608. 

  1608.         for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
    1609. 

  1609.         {
    1610. 

  1610.             if( mhFonts[i] )
    1611. 

  1611.                 ::DeleteFont( mhFonts[i] );
    1612. 

  1612.             mhFonts[ i ] = 0;
    1613. 

  1613.         }
    1614. 

  1614.         mhDefFont = 0;
    1615. 

  1615.         return 0;
    1616. 

  1616.     }
    1617. 

  1617. 

  1618.     DBG_ASSERT( pFont->mpFontData, "WinSalGraphics mpFontData==NULL");
    1619. 

  1619.     mpWinFontEntry[ nFallbackLevel ] = reinterpret_cast<ImplWinFontEntry*>( pFont->mpFontEntry );
    1620. 

  1620.     mpWinFontData[ nFallbackLevel ] = static_cast<const ImplWinFontData*>( pFont->mpFontData );
    1621. 

  1621. 

  1622.     HFONT hOldFont = 0;
    1623. 

  1623.     HFONT hNewFont = ImplDoSetFont( pFont, mfFontScale[ nFallbackLevel ], hOldFont );
    1624. 

  1624.     mfCurrentFontScale = mfFontScale[nFallbackLevel];
    1625. 

  1625. 

  1626.     if( !mhDefFont )
    1627. 

  1627.     {
    1628. 

  1628.         // keep default font
    1629. 

  1629.         mhDefFont = hOldFont;
    1630. 

  1630.     }
    1631. 

  1631.     else
    1632. 

  1632.     {
    1633. 

  1633.         // release no longer referenced font handles
    1634. 

  1634.         for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
    1635. 

  1635.         {
    1636. 

  1636.             if( mhFonts[i] )
    1637. 

  1637.             {
    1638. 

  1638.                 ::DeleteFont( mhFonts[i] );
    1639. 

  1639.                 mhFonts[i] = 0;
    1640. 

  1640.             }
    1641. 

  1641.         }
    1642. 

  1642.     }
    1643. 

  1643. 

  1644.     // store new font in correct layer
    1645. 

  1645.     mhFonts[ nFallbackLevel ] = hNewFont;
    1646. 

  1646.     // now the font is live => update font face
    1647. 

  1647.     if( mpWinFontData[ nFallbackLevel ] )
    1648. 

  1648.         mpWinFontData[ nFallbackLevel ]->UpdateFromHDC( mhDC );
    1649. 

  1649. 

  1650.     if( !nFallbackLevel )
    1651. 

  1651.     {
    1652. 

  1652.         mbFontKernInit = TRUE;
    1653. 

  1653.         if ( mpFontKernPairs )
    1654. 

  1654.         {
    1655. 

  1655.             delete[] mpFontKernPairs;
    1656. 

  1656.             mpFontKernPairs = NULL;
    1657. 

  1657.         }
    1658. 

  1658.         mnFontKernPairCount = 0;
    1659. 

  1659.     }
    1660. 

  1660. 

  1661.     mnFontCharSetCount = 0;
    1662. 

  1662. 

  1663.     // some printers have higher internal resolution, so their
    1664. 

  1664.     // text output would be different from what we calculated
    1665. 

  1665.     // => suggest DrawTextArray to workaround this problem
    1666. 

  1666.     if ( mbPrinter )
    1667. 

  1667.         return SAL_SETFONT_USEDRAWTEXTARRAY;
    1668. 

  1668.     else
    1669. 

  1669.         return 0;
    1670. 

  1670. }
    1671. 

  1671. 

  1672. // -----------------------------------------------------------------------
    1673. 

  1673. 

  1674. void WinSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
    1675. 

  1675. {
    1676. 

  1676.     // temporarily change the HDC to the font in the fallback level
    1677. 

  1677.     HFONT hOldFont = SelectFont( mhDC, mhFonts[nFallbackLevel] );
    1678. 

  1678. 

  1679.     wchar_t aFaceName[LF_FACESIZE+60];
    1680. 

  1680.     if( ::GetTextFaceW( mhDC, sizeof(aFaceName)/sizeof(wchar_t), aFaceName ) )
    1681. 

  1681.         pMetric->maName = reinterpret_cast<const sal_Unicode*>(aFaceName);
    1682. 

  1682. 

  1683.     // get the font metric
    1684. 

  1684.     TEXTMETRICA aWinMetric;
    1685. 

  1685.     const bool bOK = GetTextMetricsA( mhDC, &aWinMetric );
    1686. 

  1686.     // restore the HDC to the font in the base level
    1687. 

  1687.     SelectFont( mhDC, hOldFont );
    1688. 

  1688.     if( !bOK )
    1689. 

  1689.         return;
    1690. 

  1690. 

  1691.     // device independent font attributes
    1692. 

  1692.     pMetric->meFamily       = ImplFamilyToSal( aWinMetric.tmPitchAndFamily );
    1693. 

  1693.     pMetric->mbSymbolFlag   = (aWinMetric.tmCharSet == SYMBOL_CHARSET);
    1694. 

  1694.     pMetric->meWeight       = ImplWeightToSal( aWinMetric.tmWeight );
    1695. 

  1695.     pMetric->mePitch        = ImplMetricPitchToSal( aWinMetric.tmPitchAndFamily );
    1696. 

  1696.     pMetric->meItalic       = aWinMetric.tmItalic ? ITALIC_NORMAL : ITALIC_NONE;
    1697. 

  1697.     pMetric->mnSlant        = 0;
    1698. 

  1698. 

  1699.     // device dependend font attributes
    1700. 

  1700.     pMetric->mbDevice       = (aWinMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    1701. 

  1701.     pMetric->mbScalableFont = (aWinMetric.tmPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) != 0;
    1702. 

  1702.     if( pMetric->mbScalableFont )
    1703. 

  1703.     {
    1704. 

  1704.         // check if there are kern pairs
    1705. 

  1705.         // TODO: does this work with GPOS kerning?
    1706. 

  1706.         DWORD nKernPairs = ::GetKerningPairsA( mhDC, 0, NULL );
    1707. 

  1707.         pMetric->mbKernableFont = (nKernPairs > 0);
    1708. 

  1708.     }
    1709. 

  1709.     else
    1710. 

  1710.     {
    1711. 

  1711.         // bitmap fonts cannot be rotated directly
    1712. 

  1712.         pMetric->mnOrientation  = 0;
    1713. 

  1713.         // bitmap fonts have no kerning
    1714. 

  1714.         pMetric->mbKernableFont = false;
    1715. 

  1715.     }
    1716. 

  1716. 

  1717.     // transformation dependend font metrics
    1718. 

  1718.     pMetric->mnWidth        = static_cast<int>( mfFontScale[nFallbackLevel] * aWinMetric.tmAveCharWidth );
    1719. 

  1719.     pMetric->mnIntLeading   = static_cast<int>( mfFontScale[nFallbackLevel] * aWinMetric.tmInternalLeading );
    1720. 

  1720.     pMetric->mnExtLeading   = static_cast<int>( mfFontScale[nFallbackLevel] * aWinMetric.tmExternalLeading );
    1721. 

  1721.     pMetric->mnAscent       = static_cast<int>( mfFontScale[nFallbackLevel] * aWinMetric.tmAscent );
    1722. 

  1722.     pMetric->mnDescent      = static_cast<int>( mfFontScale[nFallbackLevel] * aWinMetric.tmDescent );
    1723. 

  1723. 

  1724.     // #107888# improved metric compatibility for Asian fonts...
    1725. 

  1725.     // TODO: assess workaround below for CWS >= extleading
    1726. 

  1726.     // TODO: evaluate use of aWinMetric.sTypo* members for CJK
    1727. 

  1727.     if( mpWinFontData[nFallbackLevel] && mpWinFontData[nFallbackLevel]->SupportsCJK() )
    1728. 

  1728.     {
    1729. 

  1729.         pMetric->mnIntLeading += pMetric->mnExtLeading;
    1730. 

  1730. 

  1731.         // #109280# The line height for Asian fonts is too small.
    1732. 

  1732.         // Therefore we add half of the external leading to the
    1733. 

  1733.         // ascent, the other half is added to the descent.
    1734. 

  1734.         const long nHalfTmpExtLeading = pMetric->mnExtLeading / 2;
    1735. 

  1735.         const long nOtherHalfTmpExtLeading = pMetric->mnExtLeading - nHalfTmpExtLeading;
    1736. 

  1736. 

  1737.         // #110641# external leading for Asian fonts.
    1738. 

  1738.         // The factor 0.3 has been confirmed with experiments.
    1739. 

  1739.         long nCJKExtLeading = static_cast<long>(0.30 * (pMetric->mnAscent + pMetric->mnDescent));
    1740. 

  1740.         nCJKExtLeading -= pMetric->mnExtLeading;
    1741. 

  1741.         pMetric->mnExtLeading = (nCJKExtLeading > 0) ? nCJKExtLeading : 0;
    1742. 

  1742. 

  1743.         pMetric->mnAscent   += nHalfTmpExtLeading;
    1744. 

  1744.         pMetric->mnDescent  += nOtherHalfTmpExtLeading;
    1745. 

  1745.     }
    1746. 

  1746. 

  1747.     pMetric->mnMinKashida = GetMinKashidaWidth();
    1748. 

  1748. }
    1749. 

  1749. 

  1750. // -----------------------------------------------------------------------
    1751. 

  1751. 

  1752. sal_uLong WinSalGraphics::GetKernPairs( sal_uLong nPairs, ImplKernPairData* pKernPairs )
    1753. 

  1753. {
    1754. 

  1754.     DBG_ASSERT( sizeof( KERNINGPAIR ) == sizeof( ImplKernPairData ),
    1755. 

  1755.                 "WinSalGraphics::GetKernPairs(): KERNINGPAIR != ImplKernPairData" );
    1756. 

  1756. 

  1757.     if ( mbFontKernInit )
    1758. 

  1758.     {
    1759. 

  1759.         if( mpFontKernPairs )
    1760. 

  1760.         {
    1761. 

  1761.             delete[] mpFontKernPairs;
    1762. 

  1762.             mpFontKernPairs = NULL;
    1763. 

  1763.         }
    1764. 

  1764.         mnFontKernPairCount = 0;
    1765. 

  1765. 

  1766.         KERNINGPAIR* pPairs = NULL;
    1767. 

  1767.         int nCount = ::GetKerningPairsW( mhDC, 0, NULL );
    1768. 

  1768.         if( nCount )
    1769. 

  1769.         {
    1770. 

  1770.             pPairs = new KERNINGPAIR[ nCount+1 ];
    1771. 

  1771.             mpFontKernPairs = pPairs;
    1772. 

  1772.             mnFontKernPairCount = nCount;
    1773. 

  1773.             ::GetKerningPairsW( mhDC, nCount, pPairs );
    1774. 

  1774.         }
    1775. 

  1775. 

  1776.         mbFontKernInit = FALSE;
    1777. 

  1777. 

  1778.         std::sort( mpFontKernPairs, mpFontKernPairs + mnFontKernPairCount, ImplCmpKernData );
    1779. 

  1779.     }
    1780. 

  1780. 

  1781.     if( !pKernPairs )
    1782. 

  1782.         return mnFontKernPairCount;
    1783. 

  1783.     else if( mpFontKernPairs )
    1784. 

  1784.     {
    1785. 

  1785.         if ( nPairs < mnFontKernPairCount )
    1786. 

  1786.             nPairs = mnFontKernPairCount;
    1787. 

  1787.         memcpy( pKernPairs, mpFontKernPairs,
    1788. 

  1788.                 nPairs*sizeof( ImplKernPairData ) );
    1789. 

  1789.         return nPairs;
    1790. 

  1790.     }
    1791. 

  1791. 

  1792.     return 0;
    1793. 

  1793. }
    1794. 

  1794. 

  1795. // -----------------------------------------------------------------------
    1796. 

  1796. 

  1797. const ImplFontCharMap* WinSalGraphics::GetImplFontCharMap() const
    1798. 

  1798. {
    1799. 

  1799.     if( !mpWinFontData[0] )
    1800. 

  1800.         return ImplFontCharMap::GetDefaultMap();
    1801. 

  1801.     return mpWinFontData[0]->GetImplFontCharMap();
    1802. 

  1802. }
    1803. 

  1803. 

  1804. bool WinSalGraphics::GetImplFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
    1805. 

  1805. {
    1806. 

  1806.     if( !mpWinFontData[0] )
    1807. 

  1807.         return false;
    1808. 

  1808.     return mpWinFontData[0]->GetImplFontCapabilities(rFontCapabilities);
    1809. 

  1809. }
    1810. 

  1810. 

  1811. // -----------------------------------------------------------------------
    1812. 

  1812. 

  1813. int CALLBACK SalEnumFontsProcExA( const ENUMLOGFONTEXA* pLogFont,
    1814. 

  1814.                                   const NEWTEXTMETRICEXA* pMetric,
    1815. 

  1815.                                   DWORD nFontType, LPARAM lParam )
    1816. 

  1816. {
    1817. 

  1817.     ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
    1818. 

  1818.     if ( !pInfo->mpName )
    1819. 

  1819.     {
    1820. 

  1820.         // Ignore vertical fonts
    1821. 

  1821.         if ( pLogFont->elfLogFont.lfFaceName[0] != '@' )
    1822. 

  1822.         {
    1823. 

  1823.             if ( !pInfo->mbImplSalCourierNew )
    1824. 

  1824.                 pInfo->mbImplSalCourierNew = stricmp( pLogFont->elfLogFont.lfFaceName, "Courier New" ) == 0;
    1825. 

  1825.             if ( !pInfo->mbImplSalCourierScalable )
    1826. 

  1826.                 pInfo->mbCourier = stricmp( pLogFont->elfLogFont.lfFaceName, "Courier" ) == 0;
    1827. 

  1827.             else
    1828. 

  1828.                 pInfo->mbCourier = FALSE;
    1829. 

  1829.             String aName( ImplSalGetUniString( pLogFont->elfLogFont.lfFaceName ) );
    1830. 

  1830.             pInfo->mpName = &aName;
    1831. 

  1831.             strncpy( pInfo->mpLogFontA->lfFaceName, pLogFont->elfLogFont.lfFaceName, LF_FACESIZE );
    1832. 

  1832.             pInfo->mpLogFontA->lfCharSet = pLogFont->elfLogFont.lfCharSet;
    1833. 

  1833.             EnumFontFamiliesExA( pInfo->mhDC, pInfo->mpLogFontA, (FONTENUMPROCA)SalEnumFontsProcExA,
    1834. 

  1834.                                  (LPARAM)(void*)pInfo, 0 );
    1835. 

  1835.             pInfo->mpLogFontA->lfFaceName[0] = '\0';
    1836. 

  1836.             pInfo->mpLogFontA->lfCharSet = DEFAULT_CHARSET;
    1837. 

  1837.             pInfo->mpName = NULL;
    1838. 

  1838.             pInfo->mbCourier = FALSE;
    1839. 

  1839.         }
    1840. 

  1840.     }
    1841. 

  1841.     else
    1842. 

  1842.     {
    1843. 

  1843.         // ignore non-scalable non-device font on printer
    1844. 

  1844.         if( pInfo->mbPrinter )
    1845. 

  1845.             if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
    1846. 

  1846.                 return 1;
    1847. 

  1847. 

  1848.         ImplWinFontData* pData = ImplLogMetricToDevFontDataA( pLogFont, &(pMetric->ntmTm), nFontType );
    1849. 

  1849.         pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
    1850. 

  1850. 

  1851.         // prefer the system character set, so that we get as much as
    1852. 

  1852.         // possible important characters. In the other case we could only
    1853. 

  1853.         // display a limited set of characters (#87309#)
    1854. 

  1854.         if ( pInfo->mnPreferedCharSet == pLogFont->elfLogFont.lfCharSet )
    1855. 

  1855.             pData->mnQuality += 100;
    1856. 

  1856. 

  1857.         // knowing Courier to be scalable is nice
    1858. 

  1858.         if( pInfo->mbCourier )
    1859. 

  1859.             pInfo->mbImplSalCourierScalable |= pData->IsScalable();
    1860. 

  1860. 

  1861.         pInfo->mpList->Add( pData );
    1862. 

  1862.     }
    1863. 

  1863. 

  1864.     return 1;
    1865. 

  1865. }
    1866. 

  1866. 

  1867. // -----------------------------------------------------------------------
    1868. 

  1868. 

  1869. int CALLBACK SalEnumFontsProcExW( const ENUMLOGFONTEXW* pLogFont,
    1870. 

  1870.                                   const NEWTEXTMETRICEXW* pMetric,
    1871. 

  1871.                                   DWORD nFontType, LPARAM lParam )
    1872. 

  1872. {
    1873. 

  1873.     ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
    1874. 

  1874.     if ( !pInfo->mpName )
    1875. 

  1875.     {
    1876. 

  1876.         // Ignore vertical fonts
    1877. 

  1877.         if ( pLogFont->elfLogFont.lfFaceName[0] != '@' )
    1878. 

  1878.         {
    1879. 

  1879.             if ( !pInfo->mbImplSalCourierNew )
    1880. 

  1880.                 pInfo->mbImplSalCourierNew = ImplSalWICompareAscii( pLogFont->elfLogFont.lfFaceName, "Courier New" ) == 0;
    1881. 

  1881.             if ( !pInfo->mbImplSalCourierScalable )
    1882. 

  1882.                 pInfo->mbCourier = ImplSalWICompareAscii( pLogFont->elfLogFont.lfFaceName, "Courier" ) == 0;
    1883. 

  1883.             else
    1884. 

  1884.                 pInfo->mbCourier = FALSE;
    1885. 

  1885.             String aName = rtl::OUString(reinterpret_cast<const sal_Unicode*>(pLogFont->elfLogFont.lfFaceName));
    1886. 

  1886.             pInfo->mpName = &aName;
    1887. 

  1887.             memcpy( pInfo->mpLogFontW->lfFaceName, pLogFont->elfLogFont.lfFaceName, (aName.Len()+1)*sizeof( wchar_t ) );
    1888. 

  1888.             pInfo->mpLogFontW->lfCharSet = pLogFont->elfLogFont.lfCharSet;
    1889. 

  1889.             EnumFontFamiliesExW( pInfo->mhDC, pInfo->mpLogFontW, (FONTENUMPROCW)SalEnumFontsProcExW,
    1890. 

  1890.                                  (LPARAM)(void*)pInfo, 0 );
    1891. 

  1891.             pInfo->mpLogFontW->lfFaceName[0] = '\0';
    1892. 

  1892.             pInfo->mpLogFontW->lfCharSet = DEFAULT_CHARSET;
    1893. 

  1893.             pInfo->mpName = NULL;
    1894. 

  1894.             pInfo->mbCourier = FALSE;
    1895. 

  1895.         }
    1896. 

  1896.     }
    1897. 

  1897.     else
    1898. 

  1898.     {
    1899. 

  1899.         // ignore non-scalable non-device font on printer
    1900. 

  1900.         if( pInfo->mbPrinter )
    1901. 

  1901.             if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
    1902. 

  1902.                 return 1;
    1903. 

  1903. 

  1904.         ImplWinFontData* pData = ImplLogMetricToDevFontDataW( pLogFont, &(pMetric->ntmTm), nFontType );
    1905. 

  1905.         pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
    1906. 

  1906. 

  1907.         // knowing Courier to be scalable is nice
    1908. 

  1908.         if( pInfo->mbCourier )
    1909. 

  1909.             pInfo->mbImplSalCourierScalable |= pData->IsScalable();
    1910. 

  1910. 

  1911.         pInfo->mpList->Add( pData );
    1912. 

  1912.     }
    1913. 

  1913. 

  1914.     return 1;
    1915. 

  1915. }
    1916. 

  1916. 

  1917. // -----------------------------------------------------------------------
    1918. 

  1918. 

  1919. struct TempFontItem
    1920. 

  1920. {
    1921. 

  1921.     ::rtl::OUString maFontFilePath;
    1922. 

  1922.     ::rtl::OString maResourcePath;
    1923. 

  1923.     TempFontItem* mpNextItem;
    1924. 

  1924. };
    1925. 

  1925. 

  1926. #ifdef FR_PRIVATE
    1927. 

  1927. static int WINAPI __AddFontResourceExW( LPCWSTR lpszfileName, DWORD fl, PVOID pdv )
    1928. 

  1928. {
    1929. 

  1929.     typedef int (WINAPI *AddFontResourceExW_FUNC)(LPCWSTR, DWORD, PVOID );
    1930. 

  1930. 

  1931.     static AddFontResourceExW_FUNC  pFunc = NULL;
    1932. 

  1932.     static HMODULE                  hmGDI = NULL;
    1933. 

  1933. 

  1934.     if ( !pFunc && !hmGDI )
    1935. 

  1935.     {
    1936. 

  1936.         hmGDI = GetModuleHandleA( "GDI32" );
    1937. 

  1937.         if ( hmGDI )
    1938. 

  1938.             pFunc = reinterpret_cast<AddFontResourceExW_FUNC>( GetProcAddress( hmGDI, "AddFontResourceExW" ) );
    1939. 

  1939.     }
    1940. 

  1940. 

  1941.     if ( pFunc )
    1942. 

  1942.         return pFunc( lpszfileName, fl, pdv );
    1943. 

  1943.     else
    1944. 

  1944.     {
    1945. 

  1945.         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    1946. 

  1946.         return 0;
    1947. 

  1947.     }
    1948. 

  1948. }
    1949. 

  1949. #endif
    1950. 

  1950. 

  1951. bool ImplAddTempFont( SalData& rSalData, const rtl::OUString& rFontFileURL )
    1952. 

  1952. {
    1953. 

  1953.     int nRet = 0;
    1954. 

  1954.     ::rtl::OUString aUSytemPath;
    1955. 

  1955.     OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
    1956. 

  1956. 

  1957. #ifdef FR_PRIVATE
    1958. 

  1958.     nRet = __AddFontResourceExW( reinterpret_cast<LPCWSTR>(aUSytemPath.getStr()), FR_PRIVATE, NULL );
    1959. 

  1959. #endif
    1960. 

  1960. 

  1961.     if ( !nRet )
    1962. 

  1962.     {
    1963. 

  1963.         static int nCounter = 0;
    1964. 

  1964.         char aFileName[] = "soAA.fot";
    1965. 

  1965.         aFileName[2] = sal::static_int_cast<char>('A' + (15 & (nCounter>>4)));
    1966. 

  1966.         aFileName[3] = sal::static_int_cast<char>('A' + (15 & nCounter));
    1967. 

  1967.         char aResourceName[512];
    1968. 

  1968.         int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
    1969. 

  1969.         int nLen = ::GetTempPathA( nMaxLen, aResourceName );
    1970. 

  1970.         ::strncpy( aResourceName + nLen, aFileName, sizeof( aResourceName )- nLen );
    1971. 

  1971.         // security: end buffer in any case
    1972. 

  1972.         aResourceName[ (sizeof(aResourceName)/sizeof(*aResourceName))-1 ] = 0;
    1973. 

  1973.         ::DeleteFileA( aResourceName );
    1974. 

  1974. 

  1975.         rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
    1976. 

  1976.         ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
    1977. 

  1977.         // TODO: font should be private => need to investigate why it doesn't work then
    1978. 

  1978.         if( !::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL ) )
    1979. 

  1979.             return false;
    1980. 

  1980.         ++nCounter;
    1981. 

  1981. 

  1982.         nRet = ::AddFontResourceA( aResourceName );
    1983. 

  1983.         if( nRet > 0 )
    1984. 

  1984.         {
    1985. 

  1985.             TempFontItem* pNewItem = new TempFontItem;
    1986. 

  1986.             pNewItem->maResourcePath = rtl::OString( aResourceName );
    1987. 

  1987.             pNewItem->maFontFilePath = aUSytemPath.getStr();
    1988. 

  1988.             pNewItem->mpNextItem = rSalData.mpTempFontItem;
    1989. 

  1989.             rSalData.mpTempFontItem = pNewItem;
    1990. 

  1990.         }
    1991. 

  1991.     }
    1992. 

  1992. 

  1993.     return (nRet > 0);
    1994. 

  1994. }
    1995. 

  1995. 

  1996. // -----------------------------------------------------------------------
    1997. 

  1997. 

  1998. void ImplReleaseTempFonts( SalData& rSalData )
    1999. 

  1999. {
    2000. 

  2000.     int nCount = 0;
    2001. 

  2001.     while( TempFontItem* p = rSalData.mpTempFontItem )
    2002. 

  2002.     {
    2003. 

  2003.         ++nCount;
    2004. 

  2004.         if( p->maResourcePath.getLength() )
    2005. 

  2005.         {
    2006. 

  2006.             const char* pResourcePath = p->maResourcePath.getStr();
    2007. 

  2007.             ::RemoveFontResourceA( pResourcePath );
    2008. 

  2008.             ::DeleteFileA( pResourcePath );
    2009. 

  2009.         }
    2010. 

  2010.         else
    2011. 

  2011.         {
    2012. 

  2012.             ::RemoveFontResourceW( reinterpret_cast<LPCWSTR>(p->maFontFilePath.getStr()) );
    2013. 

  2013.         }
    2014. 

  2014. 

  2015.         rSalData.mpTempFontItem = p->mpNextItem;
    2016. 

  2016.         delete p;
    2017. 

  2017.     }
    2018. 

  2018. 

  2019. #ifndef FR_PRIVATE
    2020. 

  2020.     // notify every other application
    2021. 

  2021.     // unless the temp fonts were installed as private fonts
    2022. 

  2022.     if( nCount > 0 )
    2023. 

  2023.         ::PostMessage( HWND_BROADCAST, WM_FONTCHANGE, 0, NULL );
    2024. 

  2024. #endif // FR_PRIVATE
    2025. 

  2025. }
    2026. 

  2026. 

  2027. // -----------------------------------------------------------------------
    2028. 

  2028. 

  2029. static bool ImplGetFontAttrFromFile( const String& rFontFileURL,
    2030. 

  2030.     ImplDevFontAttributes& rDFA )
    2031. 

  2031. {
    2032. 

  2032.     ::rtl::OUString aUSytemPath;
    2033. 

  2033.     OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
    2034. 

  2034. 

  2035.     // get FontAttributes from a *fot file
    2036. 

  2036.     // TODO: use GetTTGlobalFontInfo() to access the font directly
    2037. 

  2037.     rDFA.mnQuality    = 1000;
    2038. 

  2038.     rDFA.mbDevice     = true;
    2039. 

  2039.     rDFA.meFamily     = FAMILY_DONTKNOW;
    2040. 

  2040.     rDFA.meWidthType  = WIDTH_DONTKNOW;
    2041. 

  2041.     rDFA.meWeight     = WEIGHT_DONTKNOW;
    2042. 

  2042.     rDFA.meItalic     = ITALIC_DONTKNOW;
    2043. 

  2043.     rDFA.mePitch      = PITCH_DONTKNOW;
    2044. 

  2044.     rDFA.mbSubsettable= true;
    2045. 

  2045.     rDFA.mbEmbeddable = false;
    2046. 

  2046. 

  2047.     // Create temporary file name
    2048. 

  2048.     char aFileName[] = "soAAT.fot";
    2049. 

  2049.     char aResourceName[512];
    2050. 

  2050.     int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
    2051. 

  2051.     int nLen = ::GetTempPathA( nMaxLen, aResourceName );
    2052. 

  2052.     ::strncpy( aResourceName + nLen, aFileName, Max( 0, nMaxLen - nLen ));
    2053. 

  2053.     ::DeleteFileA( aResourceName );
    2054. 

  2054. 

  2055.     // Create font resource file (typically with a .fot file name extension).
    2056. 

  2056.     rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
    2057. 

  2057.     ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
    2058. 

  2058.     ::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL );
    2059. 

  2059. 

  2060.     // Open and read the font resource file
    2061. 

  2061.     rtl::OUString aFotFileName = rtl::OStringToOUString( aResourceName, osl_getThreadTextEncoding() );
    2062. 

  2062.     osl::FileBase::getFileURLFromSystemPath( aFotFileName, aFotFileName );
    2063. 

  2063.     osl::File aFotFile( aFotFileName );
    2064. 

  2064.     osl::FileBase::RC aError = aFotFile.open( osl_File_OpenFlag_Read );
    2065. 

  2065.     if( aError != osl::FileBase::E_None )
    2066. 

  2066.         return false;
    2067. 

  2067. 

  2068.     sal_uInt64  nBytesRead = 0;
    2069. 

  2069.     char        aBuffer[4096];
    2070. 

  2070.     aFotFile.read( aBuffer, sizeof( aBuffer ), nBytesRead );
    2071. 

  2071.     // clean up temporary resource file
    2072. 

  2072.     aFotFile.close();
    2073. 

  2073.     ::DeleteFileA( aResourceName );
    2074. 

  2074. 

  2075.     // retrieve font family name from byte offset 0x4F6
    2076. 

  2076.     sal_uInt64 i = 0x4F6;
    2077. 

  2077.     sal_uInt64 nNameOfs = i;
    2078. 

  2078.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2079. 

  2079.     // skip full name
    2080. 

  2080.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2081. 

  2081.     // retrieve font style name
    2082. 

  2082.     int nStyleOfs = i;
    2083. 

  2083.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2084. 

  2084.     if( i >= nBytesRead )
    2085. 

  2085.         return false;
    2086. 

  2086. 

  2087.     // convert byte strings to unicode
    2088. 

  2088.     rDFA.maName      = String( aBuffer + nNameOfs, osl_getThreadTextEncoding() );
    2089. 

  2089.     rDFA.maStyleName = String( aBuffer + nStyleOfs, osl_getThreadTextEncoding() );
    2090. 

  2090. 

  2091.     // byte offset 0x4C7: OS2_fsSelection
    2092. 

  2092.     const char nFSS = aBuffer[ 0x4C7 ];
    2093. 

  2093.     if( nFSS & 0x01 )   // italic
    2094. 

  2094.         rDFA.meItalic = ITALIC_NORMAL;
    2095. 

  2095.     //if( nFSS & 0x20 )   // bold
    2096. 

  2096.     //   rDFA.meWeight = WEIGHT_BOLD;
    2097. 

  2097.     if( nFSS & 0x40 )   // regular
    2098. 

  2098.     {
    2099. 

  2099.         rDFA.meWeight = WEIGHT_NORMAL;
    2100. 

  2100.         rDFA.meItalic = ITALIC_NONE;
    2101. 

  2101.     }
    2102. 

  2102. 

  2103.     // byte offsets 0x4D7/0x4D8: wingdi's FW_WEIGHT
    2104. 

  2104.     int nWinWeight = (aBuffer[0x4D7] & 0xFF) + ((aBuffer[0x4D8] & 0xFF) << 8);
    2105. 

  2105.     rDFA.meWeight = ImplWeightToSal( nWinWeight );
    2106. 

  2106. 

  2107.     rDFA.mbSymbolFlag = false;          // TODO
    2108. 

  2108.     rDFA.mePitch      = PITCH_DONTKNOW; // TODO
    2109. 

  2109. 

  2110.     // byte offset 0x4DE: pitch&family
    2111. 

  2111.     rDFA.meFamily = ImplFamilyToSal( aBuffer[0x4DE] );
    2112. 

  2112. 

  2113.     // byte offsets 0x4C8/0x4C9: emunits
    2114. 

  2114.     // byte offsets 0x4CE/0x4CF: winascent
    2115. 

  2115.     // byte offsets 0x4D0/0x4D1: winascent+windescent-emunits
    2116. 

  2116.     // byte offsets 0x4DF/0x4E0: avgwidth
    2117. 

  2117.     //...
    2118. 

  2118. 

  2119.     return true;
    2120. 

  2120. }
    2121. 

  2121. 

  2122. // -----------------------------------------------------------------------
    2123. 

  2123. 

  2124. bool WinSalGraphics::AddTempDevFont( ImplDevFontList* pFontList,
    2125. 

  2125.     const rtl::OUString& rFontFileURL, const rtl::OUString& rFontName )
    2126. 

  2126. {
    2127. 

  2127.     RTL_LOGFILE_TRACE1( "WinSalGraphics::AddTempDevFont(): %s", rtl::OUStringToOString( rFontFileURL, RTL_TEXTENCODING_UTF8 ).getStr() );
    2128. 

  2128. 

  2129.     ImplDevFontAttributes aDFA;
    2130. 

  2130.     aDFA.maName = rFontName;
    2131. 

  2131.     aDFA.mnQuality    = 1000;
    2132. 

  2132.     aDFA.mbDevice     = true;
    2133. 

  2133. 

  2134.     // Search Font Name in Cache
    2135. 

  2135.     if( rFontName.isEmpty() && mpFontAttrCache )
    2136. 

  2136.         aDFA = mpFontAttrCache->GetFontAttr( rFontFileURL );
    2137. 

  2137. 

  2138.     // Retrieve font name from font resource
    2139. 

  2139.     if( !aDFA.maName.Len() )
    2140. 

  2140.     {
    2141. 

  2141.         ImplGetFontAttrFromFile( rFontFileURL, aDFA );
    2142. 

  2142.         if( mpFontAttrCache && aDFA.maName.Len() )
    2143. 

  2143.             mpFontAttrCache->AddFontAttr( rFontFileURL, aDFA );
    2144. 

  2144.     }
    2145. 

  2145. 

  2146.     if ( !aDFA.maName.Len() )
    2147. 

  2147.         return false;
    2148. 

  2148. 

  2149.     // remember temp font for cleanup later
    2150. 

  2150.     if( !ImplAddTempFont( *GetSalData(), rFontFileURL ) )
    2151. 

  2151.         return false;
    2152. 

  2152. 

  2153.     UINT nPreferedCharSet = DEFAULT_CHARSET;
    2154. 

  2154. 

  2155.     // create matching FontData struct
    2156. 

  2156.     aDFA.mbSymbolFlag = false; // TODO: how to know it without accessing the font?
    2157. 

  2157.     aDFA.meFamily     = FAMILY_DONTKNOW;
    2158. 

  2158.     aDFA.meWidthType  = WIDTH_DONTKNOW;
    2159. 

  2159.     aDFA.meWeight     = WEIGHT_DONTKNOW;
    2160. 

  2160.     aDFA.meItalic     = ITALIC_DONTKNOW;
    2161. 

  2161.     aDFA.mePitch      = PITCH_DONTKNOW;
    2162. 

  2162.     aDFA.mbSubsettable= true;
    2163. 

  2163.     aDFA.mbEmbeddable = false;
    2164. 

  2164. 

  2165.     /*
    2166. 

  2166.     // TODO: improve ImplDevFontAttributes using the "font resource file"
    2167. 

  2167.     aDFS.maName = // using "FONTRES:" from file
    2168. 

  2168.     if( rFontName != aDFS.maName )
    2169. 

  2169.         aDFS.maMapName = aFontName;
    2170. 

  2170.     */
    2171. 

  2171. 

  2172.     ImplWinFontData* pFontData = new ImplWinFontData( aDFA, 0,
    2173. 

  2173.         sal::static_int_cast<BYTE>(nPreferedCharSet),
    2174. 

  2174.         sal::static_int_cast<BYTE>(TMPF_VECTOR|TMPF_TRUETYPE) );
    2175. 

  2175.     pFontData->SetFontId( reinterpret_cast<sal_IntPtr>(pFontData) );
    2176. 

  2176.     pFontList->Add( pFontData );
    2177. 

  2177.     return true;
    2178. 

  2178. }
    2179. 

  2179. 

  2180. // -----------------------------------------------------------------------
    2181. 

  2181. 

  2182. void WinSalGraphics::GetDevFontList( ImplDevFontList* pFontList )
    2183. 

  2183. {
    2184. 

  2184.     // make sure all fonts are registered at least temporarily
    2185. 

  2185.     static bool bOnce = true;
    2186. 

  2186.     if( bOnce )
    2187. 

  2187.     {
    2188. 

  2188.         bOnce = false;
    2189. 

  2189. 

  2190.         // determine font path
    2191. 

  2191.         // since we are only interested in fonts that could not be
    2192. 

  2192.         // registered before because of missing administration rights
    2193. 

  2193.         // only the font path of the user installation is needed
    2194. 

  2194.         ::rtl::OUString aPath;
    2195. 

  2195.         osl_getExecutableFile( &aPath.pData );
    2196. 

  2196.         aPath = aPath.copy( 0, aPath.lastIndexOf('/') );
    2197. 

  2197.         String aFontDirUrl = aPath.copy( 0, aPath.lastIndexOf('/') );
    2198. 

  2198.         aFontDirUrl += String( RTL_CONSTASCII_USTRINGPARAM("/Basis/share/fonts/truetype") );
    2199. 

  2199. 

  2200.         // collect fonts in font path that could not be registered
    2201. 

  2201.         osl::Directory aFontDir( aFontDirUrl );
    2202. 

  2202.         osl::FileBase::RC rcOSL = aFontDir.open();
    2203. 

  2203.         if( rcOSL == osl::FileBase::E_None )
    2204. 

  2204.         {
    2205. 

  2205.             osl::DirectoryItem aDirItem;
    2206. 

  2206.             String aEmptyString;
    2207. 

  2207. 

  2208.             ::rtl::OUString aBootStrap;
    2209. 

  2209.             rtl::Bootstrap::get( String( RTL_CONSTASCII_USTRINGPARAM( "BRAND_BASE_DIR" ) ), aBootStrap );
    2210. 

  2210.             aBootStrap += String( RTL_CONSTASCII_USTRINGPARAM( "/program/" SAL_CONFIGFILE( "bootstrap" ) ) );
    2211. 

  2211.             rtl::Bootstrap aBootstrap( aBootStrap );
    2212. 

  2212.             ::rtl::OUString aUserPath;
    2213. 

  2213.             aBootstrap.getFrom( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserInstallation" ) ), aUserPath );
    2214. 

  2214.             aUserPath += String( RTL_CONSTASCII_USTRINGPARAM("/user/config/fontnames.dat") );
    2215. 

  2215.             String aBaseURL = aPath.copy( 0, aPath.lastIndexOf('/')+1 );
    2216. 

  2216.             mpFontAttrCache = new ImplFontAttrCache( aUserPath, aBaseURL );
    2217. 

  2217. 

  2218.             while( aFontDir.getNextItem( aDirItem, 10 ) == osl::FileBase::E_None )
    2219. 

  2219.             {
    2220. 

  2220.                 osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileURL );
    2221. 

  2221.                 rcOSL = aDirItem.getFileStatus( aFileStatus );
    2222. 

  2222.                 if ( rcOSL == osl::FileBase::E_None )
    2223. 

  2223.                     AddTempDevFont( pFontList, aFileStatus.getFileURL(), aEmptyString );
    2224. 

  2224.             }
    2225. 

  2225. 

  2226.             delete mpFontAttrCache; // destructor rewrites the cache file if needed
    2227. 

  2227.             mpFontAttrCache = NULL;
    2228. 

  2228.         }
    2229. 

  2229.     }
    2230. 

  2230. 

  2231.     ImplEnumInfo aInfo;
    2232. 

  2232.     aInfo.mhDC          = mhDC;
    2233. 

  2233.     aInfo.mpList        = pFontList;
    2234. 

  2234.     aInfo.mpName        = NULL;
    2235. 

  2235.     aInfo.mpLogFontA    = NULL;
    2236. 

  2236.     aInfo.mpLogFontW    = NULL;
    2237. 

  2237.     aInfo.mbCourier     = false;
    2238. 

  2238.     aInfo.mbPrinter     = mbPrinter;
    2239. 

  2239.     aInfo.mnFontCount   = 0;
    2240. 

  2240.     if ( !mbPrinter )
    2241. 

  2241.     {
    2242. 

  2242.         aInfo.mbImplSalCourierScalable  = false;
    2243. 

  2243.         aInfo.mbImplSalCourierNew       = false;
    2244. 

  2244.     }
    2245. 

  2245.     else
    2246. 

  2246.     {
    2247. 

  2247.         aInfo.mbImplSalCourierScalable  = true;
    2248. 

  2248.         aInfo.mbImplSalCourierNew       = true;
    2249. 

  2249.     }
    2250. 

  2250. 

  2251.     aInfo.mnPreferedCharSet = DEFAULT_CHARSET;
    2252. 

  2252.     DWORD nCP = GetACP();
    2253. 

  2253.     CHARSETINFO aCharSetInfo;
    2254. 

  2254.     if ( TranslateCharsetInfo( (DWORD*)nCP, &aCharSetInfo, TCI_SRCCODEPAGE ) )
    2255. 

  2255.         aInfo.mnPreferedCharSet = aCharSetInfo.ciCharset;
    2256. 

  2256. 

  2257.     LOGFONTW aLogFont;
    2258. 

  2258.     memset( &aLogFont, 0, sizeof( aLogFont ) );
    2259. 

  2259.     aLogFont.lfCharSet = DEFAULT_CHARSET;
    2260. 

  2260.     aInfo.mpLogFontW = &aLogFont;
    2261. 

  2261.     EnumFontFamiliesExW( mhDC, &aLogFont,
    2262. 

  2262.         (FONTENUMPROCW)SalEnumFontsProcExW, (LPARAM)(void*)&aInfo, 0 );
    2263. 

  2263. 

  2264.     // Feststellen, was es fuer Courier-Schriften auf dem Bildschirm gibt,
    2265. 

  2265.     // um in SetFont() evt. Courier auf Courier New zu mappen
    2266. 

  2266.     if ( !mbPrinter )
    2267. 

  2267.     {
    2268. 

  2268.         bImplSalCourierScalable = aInfo.mbImplSalCourierScalable;
    2269. 

  2269.         bImplSalCourierNew      = aInfo.mbImplSalCourierNew;
    2270. 

  2270.     }
    2271. 

  2271. 

  2272.     // set glyph fallback hook
    2273. 

  2273.     static WinGlyphFallbackSubstititution aSubstFallback( mhDC );
    2274. 

  2274.     pFontList->SetFallbackHook( &aSubstFallback );
    2275. 

  2275. }
    2276. 

  2276. 

  2277. void WinSalGraphics::ClearDevFontCache()
    2278. 

  2278. {
    2279. 

  2279.     //anything to do here ?
    2280. 

  2280. }
    2281. 

  2281. 

  2282. // ----------------------------------------------------------------------------
    2283. 

  2283. 

  2284. void WinSalGraphics::GetDevFontSubstList( OutputDevice* )
    2285. 

  2285. {}
    2286. 

  2286. 

  2287. // -----------------------------------------------------------------------
    2288. 

  2288. 

  2289. sal_Bool WinSalGraphics::GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& rRect )
    2290. 

  2290. {
    2291. 

  2291.     HDC hDC = mhDC;
    2292. 

  2292. 

  2293.     // use unity matrix
    2294. 

  2294.     MAT2 aMat;
    2295. 

  2295.     aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    2296. 

  2296.     aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
    2297. 

  2297. 

  2298.     UINT nGGOFlags = GGO_METRICS;
    2299. 

  2299.     if( !(nIndex & GF_ISCHAR) )
    2300. 

  2300.         nGGOFlags |= GGO_GLYPH_INDEX;
    2301. 

  2301.     nIndex &= GF_IDXMASK;
    2302. 

  2302. 

  2303.     GLYPHMETRICS aGM;
    2304. 

  2304.     aGM.gmptGlyphOrigin.x = aGM.gmptGlyphOrigin.y = 0;
    2305. 

  2305.     aGM.gmBlackBoxX = aGM.gmBlackBoxY = 0;
    2306. 

  2306.     DWORD nSize = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGM, 0, NULL, &aMat );
    2307. 

  2307.     if( nSize == GDI_ERROR )
    2308. 

  2308.         return false;
    2309. 

  2309. 

  2310.     rRect = Rectangle( Point( +aGM.gmptGlyphOrigin.x, -aGM.gmptGlyphOrigin.y ),
    2311. 

  2311.         Size( aGM.gmBlackBoxX, aGM.gmBlackBoxY ) );
    2312. 

  2312.     rRect.Left()    = static_cast<int>( mfCurrentFontScale * rRect.Left() );
    2313. 

  2313.     rRect.Right()   = static_cast<int>( mfCurrentFontScale * rRect.Right() );
    2314. 

  2314.     rRect.Top()     = static_cast<int>( mfCurrentFontScale * rRect.Top() );
    2315. 

  2315.     rRect.Bottom()  = static_cast<int>( mfCurrentFontScale * rRect.Bottom() );
    2316. 

  2316.     return true;
    2317. 

  2317. }
    2318. 

  2318. 

  2319. // -----------------------------------------------------------------------
    2320. 

  2320. 

  2321. sal_Bool WinSalGraphics::GetGlyphOutline( sal_GlyphId nIndex,
    2322. 

  2322.     ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
    2323. 

  2323. {
    2324. 

  2324.     rB2DPolyPoly.clear();
    2325. 

  2325. 

  2326.     HDC  hDC = mhDC;
    2327. 

  2327. 

  2328.     // use unity matrix
    2329. 

  2329.     MAT2 aMat;
    2330. 

  2330.     aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    2331. 

  2331.     aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
    2332. 

  2332. 

  2333.     UINT nGGOFlags = GGO_NATIVE;
    2334. 

  2334.     if( !(nIndex & GF_ISCHAR) )
    2335. 

  2335.         nGGOFlags |= GGO_GLYPH_INDEX;
    2336. 

  2336.     nIndex &= GF_IDXMASK;
    2337. 

  2337. 

  2338.     GLYPHMETRICS aGlyphMetrics;
    2339. 

  2339.     const DWORD nSize1 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGlyphMetrics, 0, NULL, &aMat );
    2340. 

  2340.     if( !nSize1 )       // blank glyphs are ok
    2341. 

  2341.         return TRUE;
    2342. 

  2342.     else if( nSize1 == GDI_ERROR )
    2343. 

  2343.         return FALSE;
    2344. 

  2344. 

  2345.     BYTE*   pData = new BYTE[ nSize1 ];
    2346. 

  2346.     const DWORD nSize2 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags,
    2347. 

  2347.               &aGlyphMetrics, nSize1, pData, &aMat );
    2348. 

  2348. 

  2349.     if( nSize1 != nSize2 )
    2350. 

  2350.         return FALSE;
    2351. 

  2351. 

  2352.     // TODO: avoid tools polygon by creating B2DPolygon directly
    2353. 

  2353.     int     nPtSize = 512;
    2354. 

  2354.     Point*  pPoints = new Point[ nPtSize ];
    2355. 

  2355.     BYTE*   pFlags = new BYTE[ nPtSize ];
    2356. 

  2356. 

  2357.     TTPOLYGONHEADER* pHeader = (TTPOLYGONHEADER*)pData;
    2358. 

  2358.     while( (BYTE*)pHeader < pData+nSize2 )
    2359. 

  2359.     {
    2360. 

  2360.         // only outline data is interesting
    2361. 

  2361.         if( pHeader->dwType != TT_POLYGON_TYPE )
    2362. 

  2362.             break;
    2363. 

  2363. 

  2364.         // get start point; next start points are end points
    2365. 

  2365.         // of previous segment
    2366. 

  2366.         sal_uInt16 nPnt = 0;
    2367. 

  2367. 

  2368.         long nX = IntTimes256FromFixed( pHeader->pfxStart.x );
    2369. 

  2369.         long nY = IntTimes256FromFixed( pHeader->pfxStart.y );
    2370. 

  2370.         pPoints[ nPnt ] = Point( nX, nY );
    2371. 

  2371.         pFlags[ nPnt++ ] = POLY_NORMAL;
    2372. 

  2372. 

  2373.         bool bHasOfflinePoints = false;
    2374. 

  2374.         TTPOLYCURVE* pCurve = (TTPOLYCURVE*)( pHeader + 1 );
    2375. 

  2375.         pHeader = (TTPOLYGONHEADER*)( (BYTE*)pHeader + pHeader->cb );
    2376. 

  2376.         while( (BYTE*)pCurve < (BYTE*)pHeader )
    2377. 

  2377.         {
    2378. 

  2378.             int nNeededSize = nPnt + 16 + 3 * pCurve->cpfx;
    2379. 

  2379.             if( nPtSize < nNeededSize )
    2380. 

  2380.             {
    2381. 

  2381.                 Point* pOldPoints = pPoints;
    2382. 

  2382.                 BYTE* pOldFlags = pFlags;
    2383. 

  2383.                 nPtSize = 2 * nNeededSize;
    2384. 

  2384.                 pPoints = new Point[ nPtSize ];
    2385. 

  2385.                 pFlags = new BYTE[ nPtSize ];
    2386. 

  2386.                 for( sal_uInt16 i = 0; i < nPnt; ++i )
    2387. 

  2387.                 {
    2388. 

  2388.                     pPoints[ i ] = pOldPoints[ i ];
    2389. 

  2389.                     pFlags[ i ] = pOldFlags[ i ];
    2390. 

  2390.                 }
    2391. 

  2391.                 delete[] pOldPoints;
    2392. 

  2392.                 delete[] pOldFlags;
    2393. 

  2393.             }
    2394. 

  2394. 

  2395.             int i = 0;
    2396. 

  2396.             if( TT_PRIM_LINE == pCurve->wType )
    2397. 

  2397.             {
    2398. 

  2398.                 while( i < pCurve->cpfx )
    2399. 

  2399.                 {
    2400. 

  2400.                     nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2401. 

  2401.                     nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2402. 

  2402.                     ++i;
    2403. 

  2403.                     pPoints[ nPnt ] = Point( nX, nY );
    2404. 

  2404.                     pFlags[ nPnt ] = POLY_NORMAL;
    2405. 

  2405.                     ++nPnt;
    2406. 

  2406.                 }
    2407. 

  2407.             }
    2408. 

  2408.             else if( TT_PRIM_QSPLINE == pCurve->wType )
    2409. 

  2409.             {
    2410. 

  2410.                 bHasOfflinePoints = true;
    2411. 

  2411.                 while( i < pCurve->cpfx )
    2412. 

  2412.                 {
    2413. 

  2413.                     // get control point of quadratic bezier spline
    2414. 

  2414.                     nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2415. 

  2415.                     nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2416. 

  2416.                     ++i;
    2417. 

  2417.                     Point aControlP( nX, nY );
    2418. 

  2418. 

  2419.                     // calculate first cubic control point
    2420. 

  2420.                     // P0 = 1/3 * (PBeg + 2 * PQControl)
    2421. 

  2421.                     nX = pPoints[ nPnt-1 ].X() + 2 * aControlP.X();
    2422. 

  2422.                     nY = pPoints[ nPnt-1 ].Y() + 2 * aControlP.Y();
    2423. 

  2423.                     pPoints[ nPnt+0 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
    2424. 

  2424.                     pFlags[ nPnt+0 ] = POLY_CONTROL;
    2425. 

  2425. 

  2426.                     // calculate endpoint of segment
    2427. 

  2427.                     nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2428. 

  2428.                     nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2429. 

  2429. 

  2430.                     if ( i+1 >= pCurve->cpfx )
    2431. 

  2431.                     {
    2432. 

  2432.                         // endpoint is either last point in segment => advance
    2433. 

  2433.                         ++i;
    2434. 

  2434.                     }
    2435. 

  2435.                     else
    2436. 

  2436.                     {
    2437. 

  2437.                         // or endpoint is the middle of two control points
    2438. 

  2438.                         nX += IntTimes256FromFixed( pCurve->apfx[ i-1 ].x );
    2439. 

  2439.                         nY += IntTimes256FromFixed( pCurve->apfx[ i-1 ].y );
    2440. 

  2440.                         nX = (nX + 1) / 2;
    2441. 

  2441.                         nY = (nY + 1) / 2;
    2442. 

  2442.                         // no need to advance, because the current point
    2443. 

  2443.                         // is the control point in next bezier spline
    2444. 

  2444.                     }
    2445. 

  2445. 

  2446.                     pPoints[ nPnt+2 ] = Point( nX, nY );
    2447. 

  2447.                     pFlags[ nPnt+2 ] = POLY_NORMAL;
    2448. 

  2448. 

  2449.                     // calculate second cubic control point
    2450. 

  2450.                     // P1 = 1/3 * (PEnd + 2 * PQControl)
    2451. 

  2451.                     nX = pPoints[ nPnt+2 ].X() + 2 * aControlP.X();
    2452. 

  2452.                     nY = pPoints[ nPnt+2 ].Y() + 2 * aControlP.Y();
    2453. 

  2453.                     pPoints[ nPnt+1 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
    2454. 

  2454.                     pFlags[ nPnt+1 ] = POLY_CONTROL;
    2455. 

  2455. 

  2456.                     nPnt += 3;
    2457. 

  2457.                 }
    2458. 

  2458.             }
    2459. 

  2459. 

  2460.             // next curve segment
    2461. 

  2461.             pCurve = (TTPOLYCURVE*)&pCurve->apfx[ i ];
    2462. 

  2462.         }
    2463. 

  2463. 

  2464.         // end point is start point for closed contour
    2465. 

  2465.         // disabled, because Polygon class closes the contour itself
    2466. 

  2466.         // pPoints[nPnt++] = pPoints[0];
    2467. 

  2467.         // #i35928#
    2468. 

  2468.         // Added again, but add only when not yet closed
    2469. 

  2469.         if(pPoints[nPnt - 1] != pPoints[0])
    2470. 

  2470.         {
    2471. 

  2471.             if( bHasOfflinePoints )
    2472. 

  2472.                 pFlags[nPnt] = pFlags[0];
    2473. 

  2473. 

  2474.             pPoints[nPnt++] = pPoints[0];
    2475. 

  2475.         }
    2476. 

  2476. 

  2477.         // convert y-coordinates W32 -> VCL
    2478. 

  2478.         for( int i = 0; i < nPnt; ++i )
    2479. 

  2479.             pPoints[i].Y() = -pPoints[i].Y();
    2480. 

  2480. 

  2481.         // insert into polypolygon
    2482. 

  2482.         Polygon aPoly( nPnt, pPoints, (bHasOfflinePoints ? pFlags : NULL) );
    2483. 

  2483.         // convert to B2DPolyPolygon
    2484. 

  2484.         // TODO: get rid of the intermediate PolyPolygon
    2485. 

  2485.         rB2DPolyPoly.append( aPoly.getB2DPolygon() );
    2486. 

  2486.     }
    2487. 

  2487. 

  2488.     delete[] pPoints;
    2489. 

  2489.     delete[] pFlags;
    2490. 

  2490. 

  2491.     delete[] pData;
    2492. 

  2492. 

  2493.     // rescaling needed for the PolyPolygon conversion
    2494. 

  2494.     if( rB2DPolyPoly.count() )
    2495. 

  2495.     {
    2496. 

  2496.         const double fFactor(mfCurrentFontScale/256);
    2497. 

  2497.         rB2DPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix(fFactor, fFactor));
    2498. 

  2498.     }
    2499. 

  2499. 

  2500.     return TRUE;
    2501. 

  2501. }
    2502. 

  2502. 

  2503. // -----------------------------------------------------------------------
    2504. 

  2504. 

  2505. class ScopedFont
    2506. 

  2506. {
    2507. 

  2507. public:
    2508. 

  2508.     explicit ScopedFont(WinSalGraphics & rData);
    2509. 

  2509. 

  2510.     ~ScopedFont();
    2511. 

  2511. 

  2512. private:
    2513. 

  2513.     WinSalGraphics & m_rData;
    2514. 

  2514.     HFONT m_hOrigFont;
    2515. 

  2515. };
    2516. 

  2516. 

  2517. ScopedFont::ScopedFont(WinSalGraphics & rData): m_rData(rData)
    2518. 

  2518. {
    2519. 

  2519.     m_hOrigFont = m_rData.mhFonts[0];
    2520. 

  2520.     m_rData.mhFonts[0] = 0; // avoid deletion of current font
    2521. 

  2521. }
    2522. 

  2522. 

  2523. ScopedFont::~ScopedFont()
    2524. 

  2524. {
    2525. 

  2525.     if( m_hOrigFont )
    2526. 

  2526.     {
    2527. 

  2527.         // restore original font, destroy temporary font
    2528. 

  2528.         HFONT hTempFont = m_rData.mhFonts[0];
    2529. 

  2529.         m_rData.mhFonts[0] = m_hOrigFont;
    2530. 

  2530.         SelectObject( m_rData.mhDC, m_hOrigFont );
    2531. 

  2531.         DeleteObject( hTempFont );
    2532. 

  2532.     }
    2533. 

  2533. }
    2534. 

  2534. 

  2535. class ScopedTrueTypeFont
    2536. 

  2536. {
    2537. 

  2537. public:
    2538. 

  2538.     inline ScopedTrueTypeFont(): m_pFont(0) {}
    2539. 

  2539. 

  2540.     ~ScopedTrueTypeFont();
    2541. 

  2541. 

  2542.     int open(void * pBuffer, sal_uInt32 nLen, sal_uInt32 nFaceNum);
    2543. 

  2543. 

  2544.     inline TrueTypeFont * get() const { return m_pFont; }
    2545. 

  2545. 

  2546. private:
    2547. 

  2547.     TrueTypeFont * m_pFont;
    2548. 

  2548. };
    2549. 

  2549. 

  2550. ScopedTrueTypeFont::~ScopedTrueTypeFont()
    2551. 

  2551. {
    2552. 

  2552.     if (m_pFont != 0)
    2553. 

  2553.         CloseTTFont(m_pFont);
    2554. 

  2554. }
    2555. 

  2555. 

  2556. int ScopedTrueTypeFont::open(void * pBuffer, sal_uInt32 nLen,
    2557. 

  2557.                              sal_uInt32 nFaceNum)
    2558. 

  2558. {
    2559. 

  2559.     OSL_ENSURE(m_pFont == 0, "already open");
    2560. 

  2560.     return OpenTTFontBuffer(pBuffer, nLen, nFaceNum, &m_pFont);
    2561. 

  2561. }
    2562. 

  2562. 

  2563. sal_Bool WinSalGraphics::CreateFontSubset( const rtl::OUString& rToFile,
    2564. 

  2564.     const PhysicalFontFace* pFont, long* pGlyphIDs, sal_uInt8* pEncoding,
    2565. 

  2565.     sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
    2566. 

  2566. {
    2567. 

  2567.     // TODO: use more of the central font-subsetting code, move stuff there if needed
    2568. 

  2568. 

  2569.     // create matching FontSelectPattern
    2570. 

  2570.     // we need just enough to get to the font file data
    2571. 

  2571.     // use height=1000 for easier debugging (to match psprint's font units)
    2572. 

  2572.     FontSelectPattern aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    2573. 

  2573. 

  2574.     // TODO: much better solution: move SetFont and restoration of old font to caller
    2575. 

  2575.     ScopedFont aOldFont(*this);
    2576. 

  2576.     float fScale = 1.0;
    2577. 

  2577.     HFONT hOldFont = 0;
    2578. 

  2578.     ImplDoSetFont( &aIFSD, fScale, hOldFont );
    2579. 

  2579. 

  2580.     ImplWinFontData* pWinFontData = (ImplWinFontData*)aIFSD.mpFontData;
    2581. 

  2581. 

  2582. #if OSL_DEBUG_LEVEL > 1
    2583. 

  2583.     // get font metrics
    2584. 

  2584.     TEXTMETRICA aWinMetric;
    2585. 

  2585.     if( !::GetTextMetricsA( mhDC, &aWinMetric ) )
    2586. 

  2586.         return FALSE;
    2587. 

  2587. 

  2588.     DBG_ASSERT( !(aWinMetric.tmPitchAndFamily & TMPF_DEVICE), "cannot subset device font" );
    2589. 

  2589.     DBG_ASSERT( aWinMetric.tmPitchAndFamily & TMPF_TRUETYPE, "can only subset TT font" );
    2590. 

  2590. #endif
    2591. 

  2591. 

  2592.     rtl::OUString aSysPath;
    2593. 

  2593.     if( osl_File_E_None != osl_getSystemPathFromFileURL( rToFile.pData, &aSysPath.pData ) )
    2594. 

  2594.         return FALSE;
    2595. 

  2595.     const rtl_TextEncoding aThreadEncoding = osl_getThreadTextEncoding();
    2596. 

  2596.     const rtl::OString aToFile(rtl::OUStringToOString(aSysPath, aThreadEncoding));
    2597. 

  2597. 

  2598.     // check if the font has a CFF-table
    2599. 

  2599.     const DWORD nCffTag = CalcTag( "CFF " );
    2600. 

  2600.     const RawFontData aRawCffData( mhDC, nCffTag );
    2601. 

  2601.     if( aRawCffData.get() )
    2602. 

  2602.     {
    2603. 

  2603.         pWinFontData->UpdateFromHDC( mhDC );
    2604. 

  2604.         const ImplFontCharMap* pCharMap = pWinFontData->GetImplFontCharMap();
    2605. 

  2605.         pCharMap->AddReference();
    2606. 

  2606. 

  2607.         long nRealGlyphIds[ 256 ];
    2608. 

  2608.         for( int i = 0; i < nGlyphCount; ++i )
    2609. 

  2609.         {
    2610. 

  2610.             // TODO: remap notdef glyph if needed
    2611. 

  2611.             // TODO: use GDI's GetGlyphIndices instead? Does it handle GSUB properly?
    2612. 

  2612.             sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
    2613. 

  2613.             if( pGlyphIDs[i] & GF_ISCHAR ) // remaining pseudo-glyphs need to be translated
    2614. 

  2614.                 nGlyphIdx = pCharMap->GetGlyphIndex( nGlyphIdx );
    2615. 

  2615.             if( (pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0) // TODO: vertical substitution
    2616. 

  2616.                 {/*####*/}
    2617. 

  2617. 

  2618.             nRealGlyphIds[i] = nGlyphIdx;
    2619. 

  2619.         }
    2620. 

  2620. 

  2621.         pCharMap->DeReference(); // TODO: and and use a RAII object
    2622. 

  2622. 

  2623.         // provide a font subset from the CFF-table
    2624. 

  2624.         FILE* pOutFile = fopen( aToFile.getStr(), "wb" );
    2625. 

  2625.         rInfo.LoadFont( FontSubsetInfo::CFF_FONT, aRawCffData.get(), aRawCffData.size() );
    2626. 

  2626.         bool bRC = rInfo.CreateFontSubset( FontSubsetInfo::TYPE1_PFB, pOutFile, NULL,
    2627. 

  2627.                 nRealGlyphIds, pEncoding, nGlyphCount, pGlyphWidths );
    2628. 

  2628.         fclose( pOutFile );
    2629. 

  2629.         return bRC;
    2630. 

  2630.     }
    2631. 

  2631. 

  2632.     // get raw font file data
    2633. 

  2633.     const RawFontData xRawFontData( mhDC, 0 );
    2634. 

  2634.     if( !xRawFontData.get() )
    2635. 

  2635.         return FALSE;
    2636. 

  2636. 

  2637.     // open font file
    2638. 

  2638.     sal_uInt32 nFaceNum = 0;
    2639. 

  2639.     if( !*xRawFontData.get() )  // TTC candidate
    2640. 

  2640.         nFaceNum = ~0U;  // indicate "TTC font extracts only"
    2641. 

  2641. 

  2642.     ScopedTrueTypeFont aSftTTF;
    2643. 

  2643.     int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
    2644. 

  2644.     if( nRC != SF_OK )
    2645. 

  2645.         return FALSE;
    2646. 

  2646. 

  2647.     TTGlobalFontInfo aTTInfo;
    2648. 

  2648.     ::GetTTGlobalFontInfo( aSftTTF.get(), &aTTInfo );
    2649. 

  2649.     rInfo.m_nFontType   = FontSubsetInfo::SFNT_TTF;
    2650. 

  2650.     rInfo.m_aPSName     = ImplSalGetUniString( aTTInfo.psname );
    2651. 

  2651.     rInfo.m_nAscent     = aTTInfo.winAscent;
    2652. 

  2652.     rInfo.m_nDescent    = aTTInfo.winDescent;
    2653. 

  2653.     rInfo.m_aFontBBox   = Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
    2654. 

  2654.                                     Point( aTTInfo.xMax, aTTInfo.yMax ) );
    2655. 

  2655.     rInfo.m_nCapHeight  = aTTInfo.yMax; // Well ...
    2656. 

  2656. 

  2657.     // subset TTF-glyphs and get their properties
    2658. 

  2658.     // take care that subset fonts require the NotDef glyph in pos 0
    2659. 

  2659.     int nOrigCount = nGlyphCount;
    2660. 

  2660.     sal_uInt16    aShortIDs[ 256 ];
    2661. 

  2661.     sal_uInt8 aTempEncs[ 256 ];
    2662. 

  2662. 

  2663.     int nNotDef=-1, i;
    2664. 

  2664.     for( i = 0; i < nGlyphCount; ++i )
    2665. 

  2665.     {
    2666. 

  2666.         aTempEncs[i] = pEncoding[i];
    2667. 

  2667.         sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
    2668. 

  2668.         if( pGlyphIDs[i] & GF_ISCHAR )
    2669. 

  2669.         {
    2670. 

  2670.             sal_Unicode cChar = static_cast<sal_Unicode>(nGlyphIdx); // TODO: sal_UCS4
    2671. 

  2671.             const bool bVertical = ((pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0);
    2672. 

  2672.             nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
    2673. 

  2673.             if( (nGlyphIdx == 0) && pFont->IsSymbolFont() )
    2674. 

  2674.             {
    2675. 

  2675.                 // #i12824# emulate symbol aliasing U+FXXX <-> U+0XXX
    2676. 

  2676.                 cChar = (cChar & 0xF000) ? (cChar & 0x00FF) : (cChar | 0xF000);
    2677. 

  2677.                 nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
    2678. 

  2678.             }
    2679. 

  2679.         }
    2680. 

  2680.         aShortIDs[i] = static_cast<sal_uInt16>( nGlyphIdx );
    2681. 

  2681.         if( !nGlyphIdx )
    2682. 

  2682.             if( nNotDef < 0 )
    2683. 

  2683.                 nNotDef = i; // first NotDef glyph found
    2684. 

  2684.     }
    2685. 

  2685. 

  2686.     if( nNotDef != 0 )
    2687. 

  2687.     {
    2688. 

  2688.         // add fake NotDef glyph if needed
    2689. 

  2689.         if( nNotDef < 0 )
    2690. 

  2690.             nNotDef = nGlyphCount++;
    2691. 

  2691. 

  2692.         // NotDef glyph must be in pos 0 => swap glyphids
    2693. 

  2693.         aShortIDs[ nNotDef ] = aShortIDs[0];
    2694. 

  2694.         aTempEncs[ nNotDef ] = aTempEncs[0];
    2695. 

  2695.         aShortIDs[0] = 0;
    2696. 

  2696.         aTempEncs[0] = 0;
    2697. 

  2697.     }
    2698. 

  2698.     DBG_ASSERT( nGlyphCount < 257, "too many glyphs for subsetting" );
    2699. 

  2699. 

  2700.     // fill pWidth array
    2701. 

  2701.     TTSimpleGlyphMetrics* pMetrics =
    2702. 

  2702.         ::GetTTSimpleGlyphMetrics( aSftTTF.get(), aShortIDs, nGlyphCount, aIFSD.mbVertical );
    2703. 

  2703.     if( !pMetrics )
    2704. 

  2704.         return FALSE;
    2705. 

  2705.     sal_uInt16 nNotDefAdv   = pMetrics[0].adv;
    2706. 

  2706.     pMetrics[0].adv         = pMetrics[nNotDef].adv;
    2707. 

  2707.     pMetrics[nNotDef].adv   = nNotDefAdv;
    2708. 

  2708.     for( i = 0; i < nOrigCount; ++i )
    2709. 

  2709.         pGlyphWidths[i] = pMetrics[i].adv;
    2710. 

  2710.     free( pMetrics );
    2711. 

  2711. 

  2712.     // write subset into destination file
    2713. 

  2713.     nRC = ::CreateTTFromTTGlyphs( aSftTTF.get(), aToFile.getStr(), aShortIDs,
    2714. 

  2714.             aTempEncs, nGlyphCount, 0, NULL, 0 );
    2715. 

  2715.     return (nRC == SF_OK);
    2716. 

  2716. }
    2717. 

  2717. 

  2718. //--------------------------------------------------------------------------
    2719. 

  2719. 

  2720. const void* WinSalGraphics::GetEmbedFontData( const PhysicalFontFace* pFont,
    2721. 

  2721.     const sal_Unicode* pUnicodes, sal_Int32* pCharWidths,
    2722. 

  2722.     FontSubsetInfo& rInfo, long* pDataLen )
    2723. 

  2723. {
    2724. 

  2724.     // create matching FontSelectPattern
    2725. 

  2725.     // we need just enough to get to the font file data
    2726. 

  2726.     FontSelectPattern aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    2727. 

  2727. 

  2728.     // TODO: much better solution: move SetFont and restoration of old font to caller
    2729. 

  2729.     ScopedFont aOldFont(*this);
    2730. 

  2730.     SetFont( &aIFSD, 0 );
    2731. 

  2731. 

  2732.     // get the raw font file data
    2733. 

  2733.     RawFontData aRawFontData( mhDC );
    2734. 

  2734.     *pDataLen = aRawFontData.size();
    2735. 

  2735.     if( !aRawFontData.get() )
    2736. 

  2736.         return NULL;
    2737. 

  2737. 

  2738.     // get important font properties
    2739. 

  2739.     TEXTMETRICA aTm;
    2740. 

  2740.     if( !::GetTextMetricsA( mhDC, &aTm ) )
    2741. 

  2741.         *pDataLen = 0;
    2742. 

  2742.     const bool bPFA = (*aRawFontData.get() < 0x80);
    2743. 

  2743.     rInfo.m_nFontType = bPFA ? FontSubsetInfo::TYPE1_PFA : FontSubsetInfo::TYPE1_PFB;
    2744. 

  2744.     WCHAR aFaceName[64];
    2745. 

  2745.     sal_Int32 nFNLen = ::GetTextFaceW( mhDC, 64, aFaceName );
    2746. 

  2746.     // #i59854# strip eventual null byte
    2747. 

  2747.     while( nFNLen > 0 && aFaceName[nFNLen-1] == 0 )
    2748. 

  2748.         nFNLen--;
    2749. 

  2749.     if( nFNLen == 0 )
    2750. 

  2750.         *pDataLen = 0;
    2751. 

  2751.     rInfo.m_aPSName     = rtl::OUString(reinterpret_cast<const sal_Unicode*>(aFaceName), nFNLen);
    2752. 

  2752.     rInfo.m_nAscent     = +aTm.tmAscent;
    2753. 

  2753.     rInfo.m_nDescent    = -aTm.tmDescent;
    2754. 

  2754.     rInfo.m_aFontBBox   = Rectangle( Point( -aTm.tmOverhang, -aTm.tmDescent ),
    2755. 

  2755.               Point( aTm.tmMaxCharWidth, aTm.tmAscent+aTm.tmExternalLeading ) );
    2756. 

  2756.     rInfo.m_nCapHeight  = aTm.tmAscent; // Well ...
    2757. 

  2757. 

  2758.     // get individual character widths
    2759. 

  2759.     for( int i = 0; i < 256; ++i )
    2760. 

  2760.     {
    2761. 

  2761.         int nCharWidth = 0;
    2762. 

  2762.         const sal_Unicode cChar = pUnicodes[i];
    2763. 

  2763.         if( !::GetCharWidth32W( mhDC, cChar, cChar, &nCharWidth ) )
    2764. 

  2764.             *pDataLen = 0;
    2765. 

  2765.         pCharWidths[i] = nCharWidth;
    2766. 

  2766.     }
    2767. 

  2767. 

  2768.     if( !*pDataLen )
    2769. 

  2769.         return NULL;
    2770. 

  2770. 

  2771.     const unsigned char* pData = aRawFontData.steal();
    2772. 

  2772.     return (void*)pData;
    2773. 

  2773. }
    2774. 

  2774. 

  2775. //--------------------------------------------------------------------------
    2776. 

  2776. 

  2777. void WinSalGraphics::FreeEmbedFontData( const void* pData, long /*nLen*/ )
    2778. 

  2778. {
    2779. 

  2779.     delete[] reinterpret_cast<char*>(const_cast<void*>(pData));
    2780. 

  2780. }
    2781. 

  2781. 

  2782. //--------------------------------------------------------------------------
    2783. 

  2783. 

  2784. const Ucs2SIntMap* WinSalGraphics::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded )
    2785. 

  2785. {
    2786. 

  2786.     // TODO: even for builtin fonts we get here... why?
    2787. 

  2787.     if( !pFont->IsEmbeddable() )
    2788. 

  2788.         return NULL;
    2789. 

  2789. 

  2790.     // fill the encoding vector
    2791. 

  2791.     // currently no nonencoded vector
    2792. 

  2792.     if( pNonEncoded )
    2793. 

  2793.         *pNonEncoded = NULL;
    2794. 

  2794. 

  2795.     const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>(pFont);
    2796. 

  2796.     const Ucs2SIntMap* pEncoding = pWinFontData->GetEncodingVector();
    2797. 

  2797.     if( pEncoding == NULL )
    2798. 

  2798.     {
    2799. 

  2799.         Ucs2SIntMap* pNewEncoding = new Ucs2SIntMap;
    2800. 

  2800.         for( sal_Unicode i = 32; i < 256; ++i )
    2801. 

  2801.             (*pNewEncoding)[i] = i;
    2802. 

  2802.         pWinFontData->SetEncodingVector( pNewEncoding );
    2803. 

  2803.     pEncoding = pNewEncoding;
    2804. 

  2804.     }
    2805. 

  2805. 

  2806.     return pEncoding;
    2807. 

  2807. }
    2808. 

  2808. 

  2809. //--------------------------------------------------------------------------
    2810. 

  2810. 

  2811. void WinSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
    2812. 

  2812.                                      bool bVertical,
    2813. 

  2813.                                      Int32Vector& rWidths,
    2814. 

  2814.                                      Ucs2UIntMap& rUnicodeEnc )
    2815. 

  2815. {
    2816. 

  2816.     // create matching FontSelectPattern
    2817. 

  2817.     // we need just enough to get to the font file data
    2818. 

  2818.     FontSelectPattern aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    2819. 

  2819. 

  2820.     // TODO: much better solution: move SetFont and restoration of old font to caller
    2821. 

  2821.     ScopedFont aOldFont(*this);
    2822. 

  2822. 

  2823.     float fScale = 0.0;
    2824. 

  2824.     HFONT hOldFont = 0;
    2825. 

  2825.     ImplDoSetFont( &aIFSD, fScale, hOldFont );
    2826. 

  2826. 

  2827.     if( pFont->IsSubsettable() )
    2828. 

  2828.     {
    2829. 

  2829.         // get raw font file data
    2830. 

  2830.         const RawFontData xRawFontData( mhDC );
    2831. 

  2831.         if( !xRawFontData.get() )
    2832. 

  2832.             return;
    2833. 

  2833. 

  2834.         // open font file
    2835. 

  2835.         sal_uInt32 nFaceNum = 0;
    2836. 

  2836.         if( !*xRawFontData.get() )  // TTC candidate
    2837. 

  2837.             nFaceNum = ~0U;  // indicate "TTC font extracts only"
    2838. 

  2838. 

  2839.         ScopedTrueTypeFont aSftTTF;
    2840. 

  2840.         int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
    2841. 

  2841.         if( nRC != SF_OK )
    2842. 

  2842.             return;
    2843. 

  2843. 

  2844.         int nGlyphs = GetTTGlyphCount( aSftTTF.get() );
    2845. 

  2845.         if( nGlyphs > 0 )
    2846. 

  2846.         {
    2847. 

  2847.             rWidths.resize(nGlyphs);
    2848. 

  2848.             std::vector<sal_uInt16> aGlyphIds(nGlyphs);
    2849. 

  2849.             for( int i = 0; i < nGlyphs; i++ )
    2850. 

  2850.                 aGlyphIds[i] = sal_uInt16(i);
    2851. 

  2851.             TTSimpleGlyphMetrics* pMetrics = ::GetTTSimpleGlyphMetrics( aSftTTF.get(),
    2852. 

  2852.                                                                         &aGlyphIds[0],
    2853. 

  2853.                                                                         nGlyphs,
    2854. 

  2854.                                                                         bVertical ? 1 : 0 );
    2855. 

  2855.             if( pMetrics )
    2856. 

  2856.             {
    2857. 

  2857.                 for( int i = 0; i< nGlyphs; i++ )
    2858. 

  2858.                     rWidths[i] = pMetrics[i].adv;
    2859. 

  2859.                 free( pMetrics );
    2860. 

  2860.                 rUnicodeEnc.clear();
    2861. 

  2861.             }
    2862. 

  2862.             const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFont);
    2863. 

  2863.             const ImplFontCharMap* pMap = pWinFont->GetImplFontCharMap();
    2864. 

  2864.             DBG_ASSERT( pMap && pMap->GetCharCount(), "no map" );
    2865. 

  2865.             pMap->AddReference();
    2866. 

  2866. 

  2867.             int nCharCount = pMap->GetCharCount();
    2868. 

  2868.             sal_uInt32 nChar = pMap->GetFirstChar();
    2869. 

  2869.             for( int i = 0; i < nCharCount; i++ )
    2870. 

  2870.             {
    2871. 

  2871.                 if( nChar < 0x00010000 )
    2872. 

  2872.                 {
    2873. 

  2873.                     sal_uInt16 nGlyph = ::MapChar( aSftTTF.get(),
    2874. 

  2874.                                                    static_cast<sal_Ucs>(nChar),
    2875. 

  2875.                                                    bVertical ? 1 : 0 );
    2876. 

  2876.                     if( nGlyph )
    2877. 

  2877.                         rUnicodeEnc[ static_cast<sal_Unicode>(nChar) ] = nGlyph;
    2878. 

  2878.                 }
    2879. 

  2879.                 nChar = pMap->GetNextChar( nChar );
    2880. 

  2880.             }
    2881. 

  2881. 

  2882.             pMap->DeReference(); // TODO: and and use a RAII object
    2883. 

  2883.         }
    2884. 

  2884.     }
    2885. 

  2885.     else if( pFont->IsEmbeddable() )
    2886. 

  2886.     {
    2887. 

  2887.         // get individual character widths
    2888. 

  2888.         rWidths.clear();
    2889. 

  2889.         rUnicodeEnc.clear();
    2890. 

  2890.         rWidths.reserve( 224 );
    2891. 

  2891.         for( sal_Unicode i = 32; i < 256; ++i )
    2892. 

  2892.         {
    2893. 

  2893.             int nCharWidth = 0;
    2894. 

  2894.             if( ::GetCharWidth32W( mhDC, i, i, &nCharWidth ) )
    2895. 

  2895.             {
    2896. 

  2896.                 rUnicodeEnc[ i ] = rWidths.size();
    2897. 

  2897.                 rWidths.push_back( nCharWidth );
    2898. 

  2898.             }
    2899. 

  2899.         }
    2900. 

  2900.     }
    2901. 

  2901. }
    2902. 

  2902. 

  2903. //--------------------------------------------------------------------------
    2904. 

  2904. 

  2905. void WinSalGraphics::DrawServerFontLayout( const ServerFontLayout& )
    2906. 

  2906. {}
    2907. 

  2907. 

  2908. //--------------------------------------------------------------------------
    2909. 

  2909. 

  2910. SystemFontData WinSalGraphics::GetSysFontData( int nFallbacklevel ) const
    2911. 

  2911. {
    2912. 

  2912.     SystemFontData aSysFontData;
    2913. 

  2913. 

  2914.     if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
    2915. 

  2915.     if (nFallbacklevel < 0 ) nFallbacklevel = 0;
    2916. 

  2916. 

  2917.     aSysFontData.hFont = mhFonts[nFallbacklevel];
    2918. 

  2918. 

  2919.     OSL_TRACE("\r\n:WinSalGraphics::GetSysFontData(): FontID: %p, Fallback level: %d",
    2920. 

  2920.               aSysFontData.hFont, nFallbacklevel);
    2921. 

  2921. 

  2922.     return aSysFontData;
    2923. 

  2923. }
    2924. 

  2924. 

  2925. //--------------------------------------------------------------------------
    2926. 

  2926. 

  2927. /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
    2928. 

  2928.