PageRenderTime 97ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 2ms

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

https://bitbucket.org/tora/ooo-enum-attribute-packed-experiment-ooo330_m20-vcl
C++ | 3229 lines | 2385 code | 466 blank | 378 comment | 498 complexity | d54f0631df34fe719281c43ab2217ee5 MD5 | raw file
    

  1. /*************************************************************************
    2. 

  2.  *
    3. 

  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4. 

  4.  * 
    5. 

  5.  * Copyright 2000, 2010 Oracle and/or its affiliates.
    6. 

  6.  *
    7. 

  7.  * OpenOffice.org - a multi-platform office productivity suite
    8. 

  8.  *
    9. 

  9.  * This file is part of OpenOffice.org.
    10. 

  10.  *
    11. 

  11.  * OpenOffice.org is free software: you can redistribute it and/or modify
    12. 

  12.  * it under the terms of the GNU Lesser General Public License version 3
    13. 

  13.  * only, as published by the Free Software Foundation.
    14. 

  14.  *
    15. 

  15.  * OpenOffice.org is distributed in the hope that it will be useful,
    16. 

  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    17. 

  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    18. 

  18.  * GNU Lesser General Public License version 3 for more details
    19. 

  19.  * (a copy is included in the LICENSE file that accompanied this code).
    20. 

  20.  *
    21. 

  21.  * You should have received a copy of the GNU Lesser General Public License
    22. 

  22.  * version 3 along with OpenOffice.org.  If not, see
    23. 

  23.  * <http://www.openoffice.org/license.html>
    24. 

  24.  * for a copy of the LGPLv3 License.
    25. 

  25.  *
    26. 

  26.  ************************************************************************/
    27. 

  27. 

  28. // MARKER(update_precomp.py): autogen include statement, do not remove
    29. 

  29. #include "precompiled_vcl.hxx"
    30. 

  30. 

  31. #include <string.h>
    32. 

  32. #include <malloc.h>
    33. 

  33. 

  34. #include <tools/prewin.h>
    35. 

  35. #include <windows.h>
    36. 

  36. #include <tools/postwin.h>
    37. 

  37. #include <vcl/sysdata.hxx>
    38. 

  38. #include "tools/svwin.h"
    39. 

  39. 

  40. #include "wincomp.hxx"
    41. 

  41. #include "saldata.hxx"
    42. 

  42. #include "salgdi.h"
    43. 

  43. 

  44. #include "vcl/svapp.hxx"
    45. 

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

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

  47. #include "vcl/fontsubset.hxx"
    48. 

  48. #include "vcl/sallayout.hxx"
    49. 

  49. 

  50. #include "vcl/outdev.h"			// for ImplGlyphFallbackFontSubstitution
    51. 

  51. #include "unotools/fontcfg.hxx"	// for IMPL_FONT_ATTR_SYMBOL
    52. 

  52. 

  53. #include "rtl/logfile.hxx"
    54. 

  54. #include "rtl/tencinfo.h"
    55. 

  55. #include "rtl/textcvt.h"
    56. 

  56. #include "rtl/bootstrap.hxx"
    57. 

  57. 

  58. #include "i18npool/mslangid.hxx"
    59. 

  59. 

  60. #include "osl/module.h"
    61. 

  61. #include "osl/file.hxx"
    62. 

  62. #include "osl/thread.hxx"
    63. 

  63. #include "osl/process.h"
    64. 

  64. 

  65. #include "tools/poly.hxx"
    66. 

  66. #include "tools/debug.hxx"
    67. 

  67. #include "tools/stream.hxx"
    68. 

  68. 

  69. #include "basegfx/polygon/b2dpolygon.hxx"
    70. 

  70. #include "basegfx/polygon/b2dpolypolygon.hxx"
    71. 

  71. #include "basegfx/matrix/b2dhommatrix.hxx"
    72. 

  72. #include <basegfx/matrix/b2dhommatrixtools.hxx>
    73. 

  73. 

  74. #include "sft.hxx"
    75. 

  75. 

  76. #ifdef GCP_KERN_HACK
    77. 

  77. #include <algorithm>
    78. 

  78. #endif
    79. 

  79. 

  80. #ifdef ENABLE_GRAPHITE
    81. 

  81. #include <graphite/GrClient.h>
    82. 

  82. #include <graphite/WinFont.h>
    83. 

  83. #endif
    84. 

  84. 

  85. #include <vector>
    86. 

  86. #include <set>
    87. 

  87. #include <map>
    88. 

  88. 

  89. using namespace vcl;
    90. 

  90. 

  91. static const int MAXFONTHEIGHT = 2048;
    92. 

  92. 

  93. // -----------
    94. 

  94. // - Inlines -
    95. 

  95. // -----------
    96. 

  96. 

  97. inline FIXED FixedFromDouble( double d )
    98. 

  98. {
    99. 

  99.     const long l = (long) ( d * 65536. );
    100. 

  100.     return *(FIXED*) &l;
    101. 

  101. }
    102. 

  102. 

  103. // -----------------------------------------------------------------------
    104. 

  104. 

  105. inline int IntTimes256FromFixed(FIXED f)
    106. 

  106. {
    107. 

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

  108.     return nFixedTimes256;
    109. 

  109. }
    110. 

  110. 

  111. // =======================================================================
    112. 

  112. 

  113. // these variables can be static because they store system wide settings
    114. 

  114. static bool bImplSalCourierScalable = false;
    115. 

  115. static bool bImplSalCourierNew = false;
    116. 

  116. 

  117. 

  118. // =======================================================================
    119. 

  119. 

  120. // -----------------------------------------------------------------------
    121. 

  121. 

  122. // TODO: also support temporary TTC font files
    123. 

  123. typedef std::map< String, ImplDevFontAttributes > FontAttrMap;
    124. 

  124. 

  125. class ImplFontAttrCache
    126. 

  126. {
    127. 

  127. private:
    128. 

  128. 	FontAttrMap		aFontAttributes;
    129. 

  129. 	rtl::OUString	aCacheFileName;
    130. 

  130. 	String			aBaseURL;
    131. 

  131. 	BOOL			bModified;
    132. 

  132. 

  133. protected:
    134. 

  134. 	String	OptimizeURL( const String& rURL ) const;
    135. 

  135. 

  136.     enum{ MAGIC = 0x12349876 }; // change if fontattrcache format changes
    137. 

  137. 

  138. public:
    139. 

  139.             ImplFontAttrCache( const String& rCacheFileName, const String& rBaseURL );
    140. 

  140.             ~ImplFontAttrCache();
    141. 

  141. 

  142.     ImplDevFontAttributes  GetFontAttr( const String& rFontFileName ) const;
    143. 

  143.     void                   AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& );
    144. 

  144. };
    145. 

  145. 

  146. ImplFontAttrCache::ImplFontAttrCache( const String& rFileNameURL, const String& rBaseURL ) : aBaseURL( rBaseURL )
    147. 

  147. {
    148. 

  148. 	bModified = FALSE;
    149. 

  149. 	aBaseURL.ToLowerAscii();	// Windows only, no problem...
    150. 

  150. 

  151.     // open the cache file
    152. 

  152.     osl::FileBase::getSystemPathFromFileURL( rFileNameURL, aCacheFileName );
    153. 

  153.     SvFileStream aCacheFile( aCacheFileName, STREAM_READ );
    154. 

  154.     if( !aCacheFile.IsOpen() )
    155. 

  155.         return;
    156. 

  156. 

  157.     // check the cache version
    158. 

  158.     sal_uInt32 nCacheMagic;
    159. 

  159.     aCacheFile >> nCacheMagic;
    160. 

  160.     if( nCacheMagic != ImplFontAttrCache::MAGIC )
    161. 

  161.         return;  // ignore cache and rewrite if no match
    162. 

  162. 

  163.     // read the cache entries from the file
    164. 

  164.     String aFontFileURL, aFontName;
    165. 

  165.     ImplDevFontAttributes aDFA;
    166. 

  166.     for(;;)
    167. 

  167.     {
    168. 

  168.         aCacheFile.ReadByteString( aFontFileURL, RTL_TEXTENCODING_UTF8 );
    169. 

  169.         if( !aFontFileURL.Len() )
    170. 

  170.             break;
    171. 

  171.         aCacheFile.ReadByteString( aDFA.maName, RTL_TEXTENCODING_UTF8 );
    172. 

  172. 

  173.         short n;
    174. 

  174.         aCacheFile >> n; aDFA.meWeight     = static_cast<FontWeight>(n);
    175. 

  175.         aCacheFile >> n; aDFA.meItalic     = static_cast<FontItalic>(n);
    176. 

  176.         aCacheFile >> n; aDFA.mePitch      = static_cast<FontPitch>(n);
    177. 

  177.         aCacheFile >> n; aDFA.meWidthType  = static_cast<FontWidth>(n);
    178. 

  178.         aCacheFile >> n; aDFA.meFamily     = static_cast<FontFamily>(n);
    179. 

  179.         aCacheFile >> n; aDFA.mbSymbolFlag = (n != 0);
    180. 

  180. 

  181.         aCacheFile.ReadByteStringLine( aDFA.maStyleName, RTL_TEXTENCODING_UTF8 );
    182. 

  182. 

  183.         aFontAttributes[ aFontFileURL ] = aDFA;
    184. 

  184.     }
    185. 

  185. }
    186. 

  186. 

  187. ImplFontAttrCache::~ImplFontAttrCache()
    188. 

  188. {
    189. 

  189. 	if ( bModified )
    190. 

  190. 	{
    191. 

  191. 		SvFileStream aCacheFile( aCacheFileName, STREAM_WRITE|STREAM_TRUNC );
    192. 

  192. 		if ( aCacheFile.IsWritable() )
    193. 

  193. 		{
    194. 

  194.             sal_uInt32 nCacheMagic = ImplFontAttrCache::MAGIC;
    195. 

  195.             aCacheFile << nCacheMagic;
    196. 

  196. 

  197. 			// write the cache entries to the file
    198. 

  198. 			FontAttrMap::const_iterator aIter = aFontAttributes.begin();
    199. 

  199. 			while ( aIter != aFontAttributes.end() )
    200. 

  200. 			{
    201. 

  201. 				const String rFontFileURL( (*aIter).first );
    202. 

  202. 				const ImplDevFontAttributes& rDFA( (*aIter).second );
    203. 

  203. 				aCacheFile.WriteByteString( rFontFileURL, RTL_TEXTENCODING_UTF8 );
    204. 

  204. 				aCacheFile.WriteByteString( rDFA.maName, RTL_TEXTENCODING_UTF8 );
    205. 

  205. 

  206.                 aCacheFile << static_cast<short>(rDFA.meWeight);
    207. 

  207.                 aCacheFile << static_cast<short>(rDFA.meItalic);
    208. 

  208.                 aCacheFile << static_cast<short>(rDFA.mePitch);
    209. 

  209.                 aCacheFile << static_cast<short>(rDFA.meWidthType);
    210. 

  210.                 aCacheFile << static_cast<short>(rDFA.meFamily);
    211. 

  211.                 aCacheFile << static_cast<short>(rDFA.mbSymbolFlag != false);
    212. 

  212. 

  213.                 aCacheFile.WriteByteStringLine( rDFA.maStyleName, RTL_TEXTENCODING_UTF8 );
    214. 

  214. 

  215. 				aIter++;
    216. 

  216. 			}
    217. 

  217. 			// EOF Marker
    218. 

  218. 			String aEmptyStr;
    219. 

  219. 			aCacheFile.WriteByteString( aEmptyStr, RTL_TEXTENCODING_UTF8 );
    220. 

  220. 		}
    221. 

  221. 	}
    222. 

  222. }
    223. 

  223. 

  224. String ImplFontAttrCache::OptimizeURL( const String& rURL ) const
    225. 

  225. {
    226. 

  226. 	String aOptimizedFontFileURL( rURL );
    227. 

  227. 	aOptimizedFontFileURL.ToLowerAscii();	// Windows only, no problem...
    228. 

  228. 	if ( aOptimizedFontFileURL.CompareTo( aBaseURL, aBaseURL.Len() ) == COMPARE_EQUAL )
    229. 

  229. 		aOptimizedFontFileURL = aOptimizedFontFileURL.Copy( aBaseURL.Len() );
    230. 

  230. 	return aOptimizedFontFileURL;
    231. 

  231. }
    232. 

  232. 

  233. ImplDevFontAttributes ImplFontAttrCache::GetFontAttr( const String& rFontFileName ) const
    234. 

  234. {
    235. 

  235. 	ImplDevFontAttributes aDFA;
    236. 

  236. 	FontAttrMap::const_iterator it = aFontAttributes.find( OptimizeURL( rFontFileName ) );
    237. 

  237. 	if( it != aFontAttributes.end() )
    238. 

  238. 	{
    239. 

  239. 		aDFA = it->second;
    240. 

  240. 	}
    241. 

  241. 	return aDFA;
    242. 

  242. }
    243. 

  243. 

  244. void ImplFontAttrCache::AddFontAttr( const String& rFontFileName, const ImplDevFontAttributes& rDFA )
    245. 

  245. {
    246. 

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

  247. 	if ( rFontFileName.Len() && rDFA.maName.Len() )
    248. 

  248. 	{
    249. 

  249. 		aFontAttributes.insert( FontAttrMap::value_type( OptimizeURL( rFontFileName ), rDFA ) );
    250. 

  250. 		bModified = TRUE;
    251. 

  251. 	}
    252. 

  252. }
    253. 

  253. 

  254. // =======================================================================
    255. 

  255. 

  256. // raw font data with a scoped lifetime
    257. 

  257. class RawFontData
    258. 

  258. {
    259. 

  259. public:
    260. 

  260.     explicit	RawFontData( HDC, DWORD nTableTag=0 );
    261. 

  261.     			~RawFontData() { delete[] mpRawBytes; }
    262. 

  262.     const unsigned char*	get() const { return mpRawBytes; }
    263. 

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

  264.     const int				size() const { return mnByteCount; }
    265. 

  265. 

  266. private:
    267. 

  267.     unsigned char*	mpRawBytes;
    268. 

  268.     int				mnByteCount;
    269. 

  269. };
    270. 

  270. 

  271. RawFontData::RawFontData( HDC hDC, DWORD nTableTag )
    272. 

  272. :	mpRawBytes( NULL )
    273. 

  273. ,	mnByteCount( 0 )
    274. 

  274. {
    275. 

  275. 	// get required size in bytes
    276. 

  276.     mnByteCount = ::GetFontData( hDC, nTableTag, 0, NULL, 0 );
    277. 

  277.     if( mnByteCount == GDI_ERROR )
    278. 

  278.         return;
    279. 

  279.     else if( !mnByteCount )
    280. 

  280.         return;
    281. 

  281. 

  282. 	// allocate the array
    283. 

  283.     mpRawBytes = new unsigned char[ mnByteCount ];
    284. 

  284. 

  285. 	// get raw data in chunks small enough for GetFontData()
    286. 

  286. 	int nRawDataOfs = 0;
    287. 

  287. 	DWORD nMaxChunkSize = 0x100000;
    288. 

  288. 	for(;;)
    289. 

  289. 	{
    290. 

  290. 		// calculate remaining raw data to get
    291. 

  291. 		DWORD nFDGet = mnByteCount - nRawDataOfs;
    292. 

  292. 		if( nFDGet <= 0 )
    293. 

  293. 			break;
    294. 

  294. 		// #i56745# limit GetFontData requests
    295. 

  295. 		if( nFDGet > nMaxChunkSize )
    296. 

  296. 			nFDGet = nMaxChunkSize;
    297. 

  297. 		const DWORD nFDGot = ::GetFontData( hDC, nTableTag, nRawDataOfs,
    298. 

  298. 			(void*)(mpRawBytes + nRawDataOfs), nFDGet );
    299. 

  299. 		if( !nFDGot )
    300. 

  300. 			break;
    301. 

  301. 		else if( nFDGot != GDI_ERROR )
    302. 

  302. 			nRawDataOfs += nFDGot;
    303. 

  303. 		else
    304. 

  304. 		{
    305. 

  305. 			// was the chunk too big? reduce it
    306. 

  306. 			nMaxChunkSize /= 2;
    307. 

  307. 			if( nMaxChunkSize < 0x10000 )
    308. 

  308. 				break;
    309. 

  309. 		}
    310. 

  310. 	}
    311. 

  311. 

  312. 	// cleanup if the raw data is incomplete
    313. 

  313. 	if( nRawDataOfs != mnByteCount )
    314. 

  314. 	{
    315. 

  315. 		delete[] mpRawBytes;
    316. 

  316. 		mpRawBytes = NULL;
    317. 

  317. 	}
    318. 

  318. }
    319. 

  319. 

  320. // ===========================================================================
    321. 

  321. // platform specific font substitution hooks for glyph fallback enhancement
    322. 

  322. // TODO: move into i18n module (maybe merge with svx/ucsubset.*
    323. 

  323. //       or merge with i18nutil/source/utility/unicode_data.h)
    324. 

  324. struct Unicode2LangType
    325. 

  325. {
    326. 

  326. 	sal_UCS4 mnMinCode;
    327. 

  327. 	sal_UCS4 mnMaxCode;
    328. 

  328. 	LanguageType mnLangID;
    329. 

  329. };
    330. 

  330. 

  331. // entries marked with default-CJK get replaced with the default-CJK language
    332. 

  332. #define LANGUAGE_DEFAULT_CJK 0xFFF0
    333. 

  333. 

  334. // map unicode ranges to languages supported by OOo
    335. 

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

  336. static Unicode2LangType aLangFromCodeChart[]= {
    337. 

  337. 	{0x0000, 0x007F, LANGUAGE_ENGLISH},				// Basic Latin
    338. 

  338. 	{0x0080, 0x024F, LANGUAGE_ENGLISH},				// Latin Extended-A and Latin Extended-B
    339. 

  339. 	{0x0250, 0x02AF, LANGUAGE_SYSTEM},				// IPA Extensions
    340. 

  340. 	{0x0370, 0x03FF, LANGUAGE_GREEK},				// Greek
    341. 

  341. 	{0x0590, 0x05FF, LANGUAGE_HEBREW},				// Hebrew
    342. 

  342. 	{0x0600, 0x06FF, LANGUAGE_ARABIC_PRIMARY_ONLY},	// Arabic
    343. 

  343. 	{0x0900, 0x097F, LANGUAGE_HINDI},				// Devanagari
    344. 

  344. 	{0x0980, 0x09FF, LANGUAGE_BENGALI},				// Bengali
    345. 

  345. 	{0x0A80, 0x0AFF, LANGUAGE_GUJARATI},			// Gujarati
    346. 

  346. 	{0x0B00, 0x0B7F, LANGUAGE_ORIYA},				// Oriya
    347. 

  347. 	{0x0B80, 0x0BFF, LANGUAGE_TAMIL},				// Tamil
    348. 

  348. 	{0x0C00, 0x0C7F, LANGUAGE_TELUGU},				// Telugu
    349. 

  349. 	{0x0C80, 0x0CFF, LANGUAGE_KANNADA},				// Kannada
    350. 

  350. 	{0x0D00, 0x0D7F, LANGUAGE_MALAYALAM},			// Malayalam
    351. 

  351. 	{0x0D80, 0x0D7F, LANGUAGE_SINHALESE_SRI_LANKA},	// Sinhala
    352. 

  352. 	{0x0E00, 0x0E7F, LANGUAGE_THAI},				// Thai
    353. 

  353. 	{0x0E80, 0x0EFF, LANGUAGE_LAO},					// Lao
    354. 

  354. 	{0x0F00, 0x0FFF, LANGUAGE_TIBETAN},				// Tibetan
    355. 

  355. 	{0x1000, 0x109F, LANGUAGE_BURMESE},				// Burmese
    356. 

  356. 	{0x10A0, 0x10FF, LANGUAGE_GEORGIAN},			// Georgian
    357. 

  357. 	{0x1100, 0x11FF, LANGUAGE_KOREAN},				// Hangul Jamo, Korean-specific
    358. 

  358. //	{0x1200, 0x139F, LANGUAGE_AMHARIC_ETHIOPIA},	// Ethiopic
    359. 

  359. //	{0x1200, 0x139F, LANGUAGE_TIGRIGNA_ETHIOPIA},	// Ethiopic
    360. 

  360. 	{0x13A0, 0x13FF, LANGUAGE_CHEROKEE_UNITED_STATES}, // Cherokee
    361. 

  361. //	{0x1400, 0x167F, LANGUAGE_CANADIAN_ABORIGINAL},	// Canadian Aboriginial Syllabics
    362. 

  362. //	{0x1680, 0x169F, LANGUAGE_OGHAM},				// Ogham
    363. 

  363. //	{0x16A0, 0x16F0, LANGUAGE_RUNIC},				// Runic
    364. 

  364. //	{0x1700, 0x171F, LANGUAGE_TAGALOG},				// Tagalog
    365. 

  365. //	{0x1720, 0x173F, LANGUAGE_HANUNOO},				// Hanunoo
    366. 

  366. //	{0x1740, 0x175F, LANGUAGE_BUHID},				// Buhid
    367. 

  367. //	{0x1760, 0x177F, LANGUAGE_TAGBANWA},			// Tagbanwa
    368. 

  368. 	{0x1780, 0x17FF, LANGUAGE_KHMER},				// Khmer
    369. 

  369. 	{0x18A0, 0x18AF, LANGUAGE_MONGOLIAN},			// Mongolian
    370. 

  370. //	{0x1900, 0x194F, LANGUAGE_LIMBU},				// Limbu
    371. 

  371. //	{0x1950, 0x197F, LANGUAGE_TAILE},				// Tai Le
    372. 

  372. //	{0x1980, 0x19DF, LANGUAGE_TAILUE},				// Tai Lue
    373. 

  373. 	{0x19E0, 0x19FF, LANGUAGE_KHMER},				// Khmer Symbols
    374. 

  374. //	{0x1A00, 0x1A1F, LANGUAGE_BUGINESE},			// Buginese/Lontara
    375. 

  375. //	{0x1B00, 0x1B7F, LANGUAGE_BALINESE},			// Balinese
    376. 

  376. //	{0x1D00, 0x1DFF, LANGUAGE_NONE},				// Phonetic Symbols
    377. 

  377. 	{0x1E00, 0x1EFF, LANGUAGE_ENGLISH},				// Latin Extended Additional
    378. 

  378. 	{0x1F00, 0x1FFF, LANGUAGE_GREEK},				// Greek Extended
    379. 

  379. 	{0x2C60, 0x2C7F, LANGUAGE_ENGLISH},				// Latin Extended-C
    380. 

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

  381. 	{0x3000, 0x303F, LANGUAGE_DEFAULT_CJK},			// CJK Symbols and punctuation
    382. 

  382. 	{0x3040, 0x30FF, LANGUAGE_JAPANESE},			// Japanese Hiragana + Katakana
    383. 

  383. 	{0x3100, 0x312F, LANGUAGE_CHINESE_TRADITIONAL},	// Bopomofo
    384. 

  384. 	{0x3130, 0x318F, LANGUAGE_KOREAN},				// Hangul Compatibility Jamo, Kocrean-specific
    385. 

  385. 	{0x3190, 0x319F, LANGUAGE_JAPANESE},			// Kanbun
    386. 

  386. 	{0x31A0, 0x31BF, LANGUAGE_CHINESE_TRADITIONAL},	// Bopomofo Extended
    387. 

  387. 	{0x31C0, 0x31EF, LANGUAGE_DEFAULT_CJK},			// CJK Ideographs
    388. 

  388. 	{0x31F0, 0x31FF, LANGUAGE_JAPANESE},			// Japanese Katakana Phonetic Extensions
    389. 

  389. 	{0x3200, 0x321F, LANGUAGE_KOREAN},				// Parenthesized Hangul
    390. 

  390. 	{0x3220, 0x325F, LANGUAGE_DEFAULT_CJK},			// Parenthesized Ideographs
    391. 

  391. 	{0x3260, 0x327F, LANGUAGE_KOREAN},				// Circled Hangul
    392. 

  392. 	{0x3280, 0x32CF, LANGUAGE_DEFAULT_CJK},			// Circled Ideographs
    393. 

  393. 	{0x32d0, 0x32FF, LANGUAGE_JAPANESE},			// Japanese Circled Katakana
    394. 

  394. 	{0x3400, 0x4DBF, LANGUAGE_DEFAULT_CJK},			// CJK Unified Ideographs Extension A
    395. 

  395. 	{0x4E00, 0x9FCF, LANGUAGE_DEFAULT_CJK},			// Unified CJK Ideographs
    396. 

  396. 	{0xA720, 0xA7FF, LANGUAGE_ENGLISH},				// Latin Extended-D
    397. 

  397. 	{0xAC00, 0xD7AF, LANGUAGE_KOREAN},				// Hangul Syllables, Korean-specific
    398. 

  398. 	{0xF900, 0xFAFF, LANGUAGE_DEFAULT_CJK},			// CJK Compatibility Ideographs
    399. 

  399. 	{0xFB00, 0xFB4F, LANGUAGE_HEBREW},				// Hebrew Presentation Forms 
    400. 

  400. 	{0xFB50, 0xFDFF, LANGUAGE_ARABIC_PRIMARY_ONLY},	// Arabic Presentation Forms-A
    401. 

  401. 	{0xFE70, 0xFEFE, LANGUAGE_ARABIC_PRIMARY_ONLY},	// Arabic Presentation Forms-B
    402. 

  402. 	{0xFF65, 0xFF9F, LANGUAGE_JAPANESE},			// Japanese Halfwidth Katakana variant
    403. 

  403. 	{0xFFA0, 0xFFDC, LANGUAGE_KOREAN},				// Kocrean halfwidth hangual variant
    404. 

  404. 	{0x10140, 0x1018F, LANGUAGE_GREEK},				// Ancient Greak numbers
    405. 

  405. 	{0x1D200, 0x1D24F, LANGUAGE_GREEK},				// Ancient Greek Musical
    406. 

  406. 	{0x20000, 0x2A6DF, LANGUAGE_DEFAULT_CJK},		// CJK Unified Ideographs Extension B
    407. 

  407. 	{0x2F800, 0x2FA1F, LANGUAGE_DEFAULT_CJK}		// CJK Compatibility Ideographs Supplement
    408. 

  408. };
    409. 

  409. 

  410. // get language matching to the missing char
    411. 

  411. LanguageType MapCharToLanguage( sal_UCS4 uChar )
    412. 

  412. {
    413. 

  413. 	// entries marked with default-CJK get replaced with the prefered CJK language
    414. 

  414. 	static bool bFirst = true;
    415. 

  415. 	if( bFirst )
    416. 

  416. 	{
    417. 

  417. 		bFirst = false;
    418. 

  418. 

  419. 		// use method suggested in #i97086# to determnine the systems default language
    420. 

  420. 		// TODO: move into i18npool or sal/osl/w32/nlsupport.c
    421. 

  421. 		LanguageType nDefaultLang = 0;
    422. 

  422. 		HKEY hKey = NULL;
    423. 

  423. 		LONG lResult = ::RegOpenKeyExA( HKEY_LOCAL_MACHINE,
    424. 

  424. 			"SYSTEM\\CurrentControlSet\\Control\\Nls\\Language",
    425. 

  425. 			0, KEY_QUERY_VALUE, &hKey );
    426. 

  426. 		char aKeyValBuf[16];
    427. 

  427. 		DWORD nKeyValSize = sizeof(aKeyValBuf);
    428. 

  428. 		if( ERROR_SUCCESS == lResult )
    429. 

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

  430. 		aKeyValBuf[ sizeof(aKeyValBuf)-1 ] = '\0';
    431. 

  431. 		if( ERROR_SUCCESS == lResult )
    432. 

  432. 			nDefaultLang = (LanguageType)rtl_str_toInt32( aKeyValBuf, 16 );
    433. 

  433. 

  434. 		// TODO: use the default-CJK language selected in
    435. 

  435. 		//	Tools->Options->LangSettings->Languages when it becomes available here
    436. 

  436. 		if( !nDefaultLang )
    437. 

  437. 			nDefaultLang = Application::GetSettings().GetUILanguage();
    438. 

  438. 

  439. 		LanguageType nDefaultCJK = LANGUAGE_CHINESE;
    440. 

  440. 		switch( nDefaultLang )
    441. 

  441. 		{
    442. 

  442. 			case LANGUAGE_JAPANESE:
    443. 

  443. 			case LANGUAGE_KOREAN:
    444. 

  444. 			case LANGUAGE_KOREAN_JOHAB:
    445. 

  445. 			case LANGUAGE_CHINESE_SIMPLIFIED:
    446. 

  446. 			case LANGUAGE_CHINESE_TRADITIONAL:
    447. 

  447. 			case LANGUAGE_CHINESE_SINGAPORE:
    448. 

  448. 			case LANGUAGE_CHINESE_HONGKONG:
    449. 

  449. 			case LANGUAGE_CHINESE_MACAU:
    450. 

  450. 				nDefaultCJK = nDefaultLang;
    451. 

  451. 				break;
    452. 

  452. 			default:
    453. 

  453. 				nDefaultCJK = LANGUAGE_CHINESE;
    454. 

  454. 				break;
    455. 

  455. 		}
    456. 

  456. 

  457. 		// change the marked entries to prefered language
    458. 

  458. 		static const int nCount = (sizeof(aLangFromCodeChart) / sizeof(*aLangFromCodeChart));
    459. 

  459. 		for( int i = 0; i < nCount; ++i )
    460. 

  460. 		{
    461. 

  461. 			if( aLangFromCodeChart[ i].mnLangID == LANGUAGE_DEFAULT_CJK )
    462. 

  462. 				aLangFromCodeChart[ i].mnLangID = nDefaultCJK;
    463. 

  463. 		}
    464. 

  464. 	}
    465. 

  465. 

  466. 	// binary search
    467. 

  467. 	int nLow = 0;
    468. 

  468. 	int nHigh = (sizeof(aLangFromCodeChart) / sizeof(*aLangFromCodeChart)) - 1;
    469. 

  469. 	while( nLow <= nHigh )
    470. 

  470. 	{
    471. 

  471. 		int nMiddle = (nHigh + nLow) / 2;
    472. 

  472. 		if( uChar < aLangFromCodeChart[ nMiddle].mnMinCode ) 
    473. 

  473. 			nHigh = nMiddle - 1;
    474. 

  474. 		else if( uChar > aLangFromCodeChart[ nMiddle].mnMaxCode )
    475. 

  475. 			nLow = nMiddle + 1;
    476. 

  476. 		else
    477. 

  477. 			return aLangFromCodeChart[ nMiddle].mnLangID;
    478. 

  478. 	}
    479. 

  479. 

  480. 	return LANGUAGE_DONTKNOW;
    481. 

  481. }
    482. 

  482. 

  483. class WinGlyphFallbackSubstititution
    484. 

  484. :    public ImplGlyphFallbackFontSubstitution
    485. 

  485. {
    486. 

  486. public:
    487. 

  487. 	explicit	WinGlyphFallbackSubstititution( HDC );
    488. 

  488. 

  489. 	bool FindFontSubstitute( ImplFontSelectData&, rtl::OUString& rMissingChars ) const;
    490. 

  490. private:
    491. 

  491. 	HDC mhDC;
    492. 

  492. 	bool HasMissingChars( const ImplFontData*, const rtl::OUString& rMissingChars ) const;
    493. 

  493. };
    494. 

  494. 

  495. inline WinGlyphFallbackSubstititution::WinGlyphFallbackSubstititution( HDC hDC )
    496. 

  496. :	mhDC( hDC )
    497. 

  497. {}
    498. 

  498. 

  499. void ImplGetLogFontFromFontSelect( HDC, const ImplFontSelectData*,
    500. 

  500. 	LOGFONTW&, bool /*bTestVerticalAvail*/ );
    501. 

  501. 

  502. // does a font face hold the given missing characters?
    503. 

  503. bool WinGlyphFallbackSubstititution::HasMissingChars( const ImplFontData* pFace, const rtl::OUString& rMissingChars ) const
    504. 

  504. {
    505. 

  505. 	const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFace);
    506. 

  506. 	const ImplFontCharMap* pCharMap = pWinFont->GetImplFontCharMap();
    507. 

  507. 	if( !pCharMap )
    508. 

  508. 	{
    509. 

  509. 		// construct a Size structure as the parameter of constructor of class ImplFontSelectData
    510. 

  510. 		const Size aSize( pFace->GetWidth(), pFace->GetHeight() );
    511. 

  511. 		// create a ImplFontSelectData object for getting s LOGFONT
    512. 

  512. 		const ImplFontSelectData aFSD( *pFace, aSize, (float)aSize.Height(), 0, false );
    513. 

  513. 		// construct log font
    514. 

  514. 		LOGFONTW aLogFont;
    515. 

  515. 		ImplGetLogFontFromFontSelect( mhDC, &aFSD, aLogFont, true );
    516. 

  516. 

  517. 		// create HFONT from log font
    518. 

  518. 		HFONT hNewFont = ::CreateFontIndirectW( &aLogFont );
    519. 

  519. 		// select the new font into device 
    520. 

  520. 		HFONT hOldFont = ::SelectFont( mhDC, hNewFont );
    521. 

  521. 

  522. 		// read CMAP table to update their pCharMap
    523. 

  523. 		pWinFont->UpdateFromHDC( mhDC );;
    524. 

  524. 

  525. 		// cleanup temporary font
    526. 

  526. 		::SelectFont( mhDC, hOldFont );
    527. 

  527. 		::DeleteFont( hNewFont );
    528. 

  528. 

  529. 		// get the new charmap
    530. 

  530. 		pCharMap = pWinFont->GetImplFontCharMap();
    531. 

  531. 	}
    532. 

  532. 

  533. 	// avoid fonts with unknown CMAP subtables for glyph fallback
    534. 

  534. 	if( !pCharMap || pCharMap->IsDefaultMap() )
    535. 

  535. 		return false;
    536. 

  536. 

  537. 	int nMatchCount = 0;
    538. 

  538. 	// static const int nMaxMatchCount = 1; // TODO: check more missing characters?
    539. 

  539. 	const sal_Int32 nStrLen = rMissingChars.getLength();
    540. 

  540. 	for( sal_Int32 nStrIdx = 0; nStrIdx < nStrLen; ++nStrIdx )
    541. 

  541. 	{ 
    542. 

  542. 		const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
    543. 

  543. 		nMatchCount += pCharMap->HasChar( uChar );
    544. 

  544. 		break; // for now
    545. 

  545. 	}
    546. 

  546. 

  547. 	const bool bHasMatches = (nMatchCount > 0);
    548. 

  548. 	return bHasMatches;
    549. 

  549. }
    550. 

  550. 

  551. // find a fallback font for missing characters
    552. 

  552. // TODO: should stylistic matches be searched and prefered?
    553. 

  553. bool WinGlyphFallbackSubstititution::FindFontSubstitute( ImplFontSelectData& rFontSelData, rtl::OUString& rMissingChars ) const
    554. 

  554. {
    555. 

  555. 	// guess a locale matching to the missing chars
    556. 

  556. 	com::sun::star::lang::Locale aLocale;
    557. 

  557. 

  558. 	sal_Int32 nStrIdx = 0;
    559. 

  559. 	const sal_Int32 nStrLen = rMissingChars.getLength();
    560. 

  560. 	while( nStrIdx < nStrLen )
    561. 

  561. 	{
    562. 

  562. 		const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
    563. 

  563. 		const LanguageType eLang = MapCharToLanguage( uChar );
    564. 

  564. 		if( eLang == LANGUAGE_DONTKNOW )
    565. 

  565. 			continue;
    566. 

  566. 		MsLangId::convertLanguageToLocale( eLang, aLocale );
    567. 

  567. 		break;
    568. 

  568. 	}
    569. 

  569. 

  570. 	// fall back to default UI locale if the missing characters are inconclusive
    571. 

  571. 	if( nStrIdx >= nStrLen )
    572. 

  572. 		aLocale = Application::GetSettings().GetUILocale();
    573. 

  573. 

  574. 	// first level fallback:
    575. 

  575. 	// try use the locale specific default fonts defined in VCL.xcu 
    576. 

  576. 	const ImplDevFontList* pDevFontList = ImplGetSVData()->maGDIData.mpScreenFontList;
    577. 

  577. 	/*const*/ ImplDevFontListData* pDevFont = pDevFontList->ImplFindByLocale( aLocale );
    578. 

  578. 	if( pDevFont )
    579. 

  579. 	{
    580. 

  580. 		const ImplFontData* 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. 	// are the missing characters symbols? 
    589. 

  589. 	pDevFont = pDevFontList->ImplFindByAttributes( IMPL_FONT_ATTR_SYMBOL,
    590. 

  590. 					rFontSelData.meWeight, rFontSelData.meWidthType,
    591. 

  591. 					rFontSelData.meFamily, rFontSelData.meItalic, rFontSelData.maSearchName );
    592. 

  592. 	if( pDevFont )
    593. 

  593. 	{
    594. 

  594. 		const ImplFontData* pFace = pDevFont->FindBestFontFace( rFontSelData );
    595. 

  595. 		if( HasMissingChars( pFace, rMissingChars ) )
    596. 

  596. 		{
    597. 

  597. 			rFontSelData.maSearchName = pDevFont->GetSearchName();
    598. 

  598. 			return true;
    599. 

  599. 		}
    600. 

  600. 	}
    601. 

  601. 

  602. 	// last level fallback, check each font type face one by one
    603. 

  603. 	const ImplGetDevFontList* pTestFontList = pDevFontList->GetDevFontList();
    604. 

  604. 	// limit the count of fonts to be checked to prevent hangs
    605. 

  605. 	static const int MAX_GFBFONT_COUNT = 600;
    606. 

  606. 	int nTestFontCount = pTestFontList->Count();
    607. 

  607. 	if( nTestFontCount > MAX_GFBFONT_COUNT )
    608. 

  608. 		nTestFontCount = MAX_GFBFONT_COUNT;
    609. 

  609. 	
    610. 

  610. 	for( int i = 0; i < nTestFontCount; ++i )
    611. 

  611. 	{
    612. 

  612. 		const ImplFontData* pFace = pTestFontList->Get( i );
    613. 

  613. 		if( !HasMissingChars( pFace, rMissingChars ) )
    614. 

  614. 			continue;
    615. 

  615. 		rFontSelData.maSearchName = pFace->maName;
    616. 

  616. 		return true;
    617. 

  617. 	}
    618. 

  618. 

  619. 	return false;
    620. 

  620. }
    621. 

  621. 

  622. // =======================================================================
    623. 

  623. 

  624. struct ImplEnumInfo
    625. 

  625. {
    626. 

  626.     HDC                 mhDC;
    627. 

  627.     ImplDevFontList*    mpList;
    628. 

  628.     String*             mpName;
    629. 

  629.     LOGFONTA*           mpLogFontA;
    630. 

  630.     LOGFONTW*           mpLogFontW;
    631. 

  631.     UINT                mnPreferedCharSet;
    632. 

  632.     bool                mbCourier;
    633. 

  633.     bool                mbImplSalCourierScalable;
    634. 

  634.     bool                mbImplSalCourierNew;
    635. 

  635.     bool                mbPrinter;
    636. 

  636.     int                 mnFontCount;
    637. 

  637. };
    638. 

  638. 

  639. // =======================================================================
    640. 

  640. 

  641. static CharSet ImplCharSetToSal( BYTE nCharSet )
    642. 

  642. {
    643. 

  643.     rtl_TextEncoding eTextEncoding;
    644. 

  644. 

  645.     if ( nCharSet == OEM_CHARSET )
    646. 

  646.     {
    647. 

  647.         UINT nCP = (USHORT)GetOEMCP();
    648. 

  648.         switch ( nCP )
    649. 

  649.         {
    650. 

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

  651.             // handled specially here:
    652. 

  652.             case 1004:  eTextEncoding = RTL_TEXTENCODING_MS_1252; break;
    653. 

  653.             case 65400: eTextEncoding = RTL_TEXTENCODING_SYMBOL; break;
    654. 

  654.             default:
    655. 

  655.                 eTextEncoding = rtl_getTextEncodingFromWindowsCodePage(nCP);
    656. 

  656.                 break;
    657. 

  657.         };
    658. 

  658.     }
    659. 

  659.     else
    660. 

  660.     {
    661. 

  661.         if( nCharSet )
    662. 

  662.             eTextEncoding = rtl_getTextEncodingFromWindowsCharset( nCharSet );
    663. 

  663.         else
    664. 

  664.             eTextEncoding = RTL_TEXTENCODING_UNICODE;
    665. 

  665.     }
    666. 

  666. 

  667.     return eTextEncoding;
    668. 

  668. }
    669. 

  669. 

  670. // -----------------------------------------------------------------------
    671. 

  671. 

  672. static FontFamily ImplFamilyToSal( BYTE nFamily )
    673. 

  673. {
    674. 

  674.     switch ( nFamily & 0xF0 )
    675. 

  675.     {
    676. 

  676.         case FF_DECORATIVE:
    677. 

  677.             return FAMILY_DECORATIVE;
    678. 

  678. 

  679.         case FF_MODERN:
    680. 

  680.             return FAMILY_MODERN;
    681. 

  681. 

  682.         case FF_ROMAN:
    683. 

  683.             return FAMILY_ROMAN;
    684. 

  684. 

  685.         case FF_SCRIPT:
    686. 

  686.             return FAMILY_SCRIPT;
    687. 

  687. 

  688.         case FF_SWISS:
    689. 

  689.             return FAMILY_SWISS;
    690. 

  690. 

  691.         default:
    692. 

  692.             break;
    693. 

  693.     }
    694. 

  694. 

  695.     return FAMILY_DONTKNOW;
    696. 

  696. }
    697. 

  697. 

  698. // -----------------------------------------------------------------------
    699. 

  699. 

  700. static BYTE ImplFamilyToWin( FontFamily eFamily )
    701. 

  701. {
    702. 

  702.     switch ( eFamily )
    703. 

  703.     {
    704. 

  704.         case FAMILY_DECORATIVE:
    705. 

  705.             return FF_DECORATIVE;
    706. 

  706. 

  707.         case FAMILY_MODERN:
    708. 

  708.             return FF_MODERN;
    709. 

  709. 

  710.         case FAMILY_ROMAN:
    711. 

  711.             return FF_ROMAN;
    712. 

  712. 

  713.         case FAMILY_SCRIPT:
    714. 

  714.             return FF_SCRIPT;
    715. 

  715. 

  716.         case FAMILY_SWISS:
    717. 

  717.             return FF_SWISS;
    718. 

  718. 

  719.         case FAMILY_SYSTEM:
    720. 

  720.             return FF_SWISS;
    721. 

  721. 

  722.         default:
    723. 

  723.             break;
    724. 

  724.     }
    725. 

  725. 

  726.     return FF_DONTCARE;
    727. 

  727. }
    728. 

  728. 

  729. // -----------------------------------------------------------------------
    730. 

  730. 

  731. static FontWeight ImplWeightToSal( int nWeight )
    732. 

  732. {
    733. 

  733.     if ( nWeight <= FW_THIN )
    734. 

  734.         return WEIGHT_THIN;
    735. 

  735.     else if ( nWeight <= FW_ULTRALIGHT )
    736. 

  736.         return WEIGHT_ULTRALIGHT;
    737. 

  737.     else if ( nWeight <= FW_LIGHT )
    738. 

  738.         return WEIGHT_LIGHT;
    739. 

  739.     else if ( nWeight < FW_MEDIUM )
    740. 

  740.         return WEIGHT_NORMAL;
    741. 

  741.     else if ( nWeight == FW_MEDIUM )
    742. 

  742.         return WEIGHT_MEDIUM;
    743. 

  743.     else if ( nWeight <= FW_SEMIBOLD )
    744. 

  744.         return WEIGHT_SEMIBOLD;
    745. 

  745.     else if ( nWeight <= FW_BOLD )
    746. 

  746.         return WEIGHT_BOLD;
    747. 

  747.     else if ( nWeight <= FW_ULTRABOLD )
    748. 

  748.         return WEIGHT_ULTRABOLD;
    749. 

  749.     else
    750. 

  750.         return WEIGHT_BLACK;
    751. 

  751. }
    752. 

  752. 

  753. // -----------------------------------------------------------------------
    754. 

  754. 

  755. static int ImplWeightToWin( FontWeight eWeight )
    756. 

  756. {
    757. 

  757.     switch ( eWeight )
    758. 

  758.     {
    759. 

  759.         case WEIGHT_THIN:
    760. 

  760.             return FW_THIN;
    761. 

  761. 

  762.         case WEIGHT_ULTRALIGHT:
    763. 

  763.             return FW_ULTRALIGHT;
    764. 

  764. 

  765.         case WEIGHT_LIGHT:
    766. 

  766.             return FW_LIGHT;
    767. 

  767. 

  768.         case WEIGHT_SEMILIGHT:
    769. 

  769.         case WEIGHT_NORMAL:
    770. 

  770.             return FW_NORMAL;
    771. 

  771. 

  772.         case WEIGHT_MEDIUM:
    773. 

  773.             return FW_MEDIUM;
    774. 

  774. 

  775.         case WEIGHT_SEMIBOLD:
    776. 

  776.             return FW_SEMIBOLD;
    777. 

  777. 

  778.         case WEIGHT_BOLD:
    779. 

  779.             return FW_BOLD;
    780. 

  780. 

  781.         case WEIGHT_ULTRABOLD:
    782. 

  782.             return FW_ULTRABOLD;
    783. 

  783. 

  784.         case WEIGHT_BLACK:
    785. 

  785.             return FW_BLACK;
    786. 

  786. 

  787.         default:
    788. 

  788.             break;
    789. 

  789.     }
    790. 

  790. 

  791.     return 0;
    792. 

  792. }
    793. 

  793. 

  794. // -----------------------------------------------------------------------
    795. 

  795. 

  796. inline FontPitch ImplLogPitchToSal( BYTE nPitch )
    797. 

  797. {
    798. 

  798.     if ( nPitch & FIXED_PITCH )
    799. 

  799.         return PITCH_FIXED;
    800. 

  800.     else
    801. 

  801.         return PITCH_VARIABLE;
    802. 

  802. }
    803. 

  803. 

  804. // -----------------------------------------------------------------------
    805. 

  805. 

  806. inline FontPitch ImplMetricPitchToSal( BYTE nPitch )
    807. 

  807. {
    808. 

  808.     // Sausaecke bei MS !! siehe NT Hilfe
    809. 

  809.     if ( !(nPitch & TMPF_FIXED_PITCH) )
    810. 

  810.         return PITCH_FIXED;
    811. 

  811.     else
    812. 

  812.         return PITCH_VARIABLE;
    813. 

  813. }
    814. 

  814. 

  815. // -----------------------------------------------------------------------
    816. 

  816. 

  817. inline BYTE ImplPitchToWin( FontPitch ePitch )
    818. 

  818. {
    819. 

  819.     if ( ePitch == PITCH_FIXED )
    820. 

  820.         return FIXED_PITCH;
    821. 

  821.     else if ( ePitch == PITCH_VARIABLE )
    822. 

  822.         return VARIABLE_PITCH;
    823. 

  823.     else
    824. 

  824.         return DEFAULT_PITCH;
    825. 

  825. }
    826. 

  826. 

  827. // -----------------------------------------------------------------------
    828. 

  828. 

  829. static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXA& rEnumFont,
    830. 

  830.     const NEWTEXTMETRICA& rMetric, DWORD nFontType )
    831. 

  831. {
    832. 

  832.     ImplDevFontAttributes aDFA;
    833. 

  833. 

  834.     const LOGFONTA rLogFont = rEnumFont.elfLogFont;
    835. 

  835. 

  836.     // get font face attributes
    837. 

  837.     aDFA.meFamily       = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
    838. 

  838.     aDFA.meWidthType    = WIDTH_DONTKNOW;
    839. 

  839.     aDFA.meWeight       = ImplWeightToSal( rLogFont.lfWeight );
    840. 

  840.     aDFA.meItalic       = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
    841. 

  841.     aDFA.mePitch        = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
    842. 

  842.     aDFA.mbSymbolFlag   = (rLogFont.lfCharSet == SYMBOL_CHARSET);
    843. 

  843. 

  844.     // get the font face name
    845. 

  845.     aDFA.maName = ImplSalGetUniString( rLogFont.lfFaceName );
    846. 

  846. 

  847.     // use the face's style name only if it looks reasonable
    848. 

  848.     const char* pStyleName = (const char*)rEnumFont.elfStyle;
    849. 

  849.     const char* pEnd = pStyleName + sizeof( rEnumFont.elfStyle );
    850. 

  850.     const char* p = pStyleName;
    851. 

  851.     for(; *p && (p < pEnd); ++p )
    852. 

  852.         if( (0x00 < *p) && (*p < 0x20) )
    853. 

  853.             break;
    854. 

  854.     if( p < pEnd )
    855. 

  855.         aDFA.maStyleName = ImplSalGetUniString( pStyleName );
    856. 

  856. 

  857.     // get device specific font attributes
    858. 

  858.     aDFA.mbOrientation  = (nFontType & RASTER_FONTTYPE) == 0;
    859. 

  859.     aDFA.mbDevice       = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    860. 

  860. 

  861.     aDFA.mbEmbeddable   = false;
    862. 

  862.     aDFA.mbSubsettable  = false;
    863. 

  863.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
    864. 

  864.      || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
    865. 

  865.         aDFA.mbSubsettable = true;
    866. 

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

  867.         aDFA.mbEmbeddable = true;
    868. 

  868. 

  869.     // heuristics for font quality
    870. 

  870.     // -   standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
    871. 

  871.     // -   subsetting > embedding > none
    872. 

  872.     aDFA.mnQuality = 0;
    873. 

  873.     if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
    874. 

  874.         aDFA.mnQuality += 50;
    875. 

  875.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
    876. 

  876.         aDFA.mnQuality += 10;
    877. 

  877.     if( aDFA.mbSubsettable )
    878. 

  878.         aDFA.mnQuality += 200;
    879. 

  879.     else if( aDFA.mbEmbeddable )
    880. 

  880.         aDFA.mnQuality += 100;
    881. 

  881. 

  882.     // #i38665# prefer Type1 versions of the standard postscript fonts
    883. 

  883.     if( aDFA.mbEmbeddable )
    884. 

  884.     {
    885. 

  885.         if( aDFA.maName.EqualsAscii( "AvantGarde" )
    886. 

  886.         ||  aDFA.maName.EqualsAscii( "Bookman" )
    887. 

  887.         ||  aDFA.maName.EqualsAscii( "Courier" )
    888. 

  888.         ||  aDFA.maName.EqualsAscii( "Helvetica" )
    889. 

  889.         ||  aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
    890. 

  890.         ||  aDFA.maName.EqualsAscii( "Palatino" )
    891. 

  891.         ||  aDFA.maName.EqualsAscii( "Symbol" )
    892. 

  892.         ||  aDFA.maName.EqualsAscii( "Times" )
    893. 

  893.         ||  aDFA.maName.EqualsAscii( "ZapfChancery" )
    894. 

  894.         ||  aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
    895. 

  895.             aDFA.mnQuality += 500;
    896. 

  896.     }
    897. 

  897. 

  898.     // TODO: add alias names
    899. 

  899.     return aDFA;
    900. 

  900. }
    901. 

  901. 

  902. // -----------------------------------------------------------------------
    903. 

  903. 

  904. static ImplDevFontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXW& rEnumFont,
    905. 

  905.     const NEWTEXTMETRICW& rMetric, DWORD nFontType )
    906. 

  906. {
    907. 

  907.     ImplDevFontAttributes aDFA;
    908. 

  908. 

  909.     const LOGFONTW rLogFont = rEnumFont.elfLogFont;
    910. 

  910. 

  911.     // get font face attributes
    912. 

  912.     aDFA.meFamily       = ImplFamilyToSal( rLogFont.lfPitchAndFamily );
    913. 

  913.     aDFA.meWidthType    = WIDTH_DONTKNOW;
    914. 

  914.     aDFA.meWeight       = ImplWeightToSal( rLogFont.lfWeight );
    915. 

  915.     aDFA.meItalic       = (rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE;
    916. 

  916.     aDFA.mePitch        = ImplLogPitchToSal( rLogFont.lfPitchAndFamily );
    917. 

  917.     aDFA.mbSymbolFlag   = (rLogFont.lfCharSet == SYMBOL_CHARSET);
    918. 

  918. 

  919.     // get the font face name
    920. 

  920.     aDFA.maName = reinterpret_cast<const sal_Unicode*>(rLogFont.lfFaceName);
    921. 

  921. 

  922.     // use the face's style name only if it looks reasonable
    923. 

  923.     const wchar_t* pStyleName = rEnumFont.elfStyle;
    924. 

  924.     const wchar_t* pEnd = pStyleName + sizeof(rEnumFont.elfStyle)/sizeof(*rEnumFont.elfStyle);
    925. 

  925.     const wchar_t* p = pStyleName;
    926. 

  926.     for(; *p && (p < pEnd); ++p )
    927. 

  927.         if( *p < 0x0020 )
    928. 

  928.             break;
    929. 

  929.     if( p < pEnd )
    930. 

  930.         aDFA.maStyleName = reinterpret_cast<const sal_Unicode*>(pStyleName);
    931. 

  931. 

  932.     // get device specific font attributes
    933. 

  933.     aDFA.mbOrientation  = (nFontType & RASTER_FONTTYPE) == 0;
    934. 

  934.     aDFA.mbDevice       = (rMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    935. 

  935. 

  936.     aDFA.mbEmbeddable   = false;
    937. 

  937.     aDFA.mbSubsettable  = false;
    938. 

  938.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE))
    939. 

  939.      || 0 != (rMetric.tmPitchAndFamily & TMPF_TRUETYPE))
    940. 

  940.         aDFA.mbSubsettable = true;
    941. 

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

  942.         aDFA.mbEmbeddable = true;
    943. 

  943. 

  944.     // heuristics for font quality
    945. 

  945.     // -   standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
    946. 

  946.     // -   subsetting > embedding > none
    947. 

  947.     aDFA.mnQuality = 0;
    948. 

  948.     if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
    949. 

  949.         aDFA.mnQuality += 50;
    950. 

  950.     if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
    951. 

  951.         aDFA.mnQuality += 10;
    952. 

  952.     if( aDFA.mbSubsettable )
    953. 

  953.         aDFA.mnQuality += 200;
    954. 

  954.     else if( aDFA.mbEmbeddable )
    955. 

  955.         aDFA.mnQuality += 100;
    956. 

  956. 

  957.     // #i38665# prefer Type1 versions of the standard postscript fonts
    958. 

  958.     if( aDFA.mbEmbeddable )
    959. 

  959.     {
    960. 

  960.         if( aDFA.maName.EqualsAscii( "AvantGarde" )
    961. 

  961.         ||  aDFA.maName.EqualsAscii( "Bookman" )
    962. 

  962.         ||  aDFA.maName.EqualsAscii( "Courier" )
    963. 

  963.         ||  aDFA.maName.EqualsAscii( "Helvetica" )
    964. 

  964.         ||  aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
    965. 

  965.         ||  aDFA.maName.EqualsAscii( "Palatino" )
    966. 

  966.         ||  aDFA.maName.EqualsAscii( "Symbol" )
    967. 

  967.         ||  aDFA.maName.EqualsAscii( "Times" )
    968. 

  968.         ||  aDFA.maName.EqualsAscii( "ZapfChancery" )
    969. 

  969.         ||  aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
    970. 

  970.             aDFA.mnQuality += 500;
    971. 

  971.     }
    972. 

  972. 

  973.     // TODO: add alias names
    974. 

  974.     return aDFA;
    975. 

  975. }
    976. 

  976. 

  977. // -----------------------------------------------------------------------
    978. 

  978. 

  979. static ImplWinFontData* ImplLogMetricToDevFontDataA( const ENUMLOGFONTEXA* pLogFont,
    980. 

  980.                                          const NEWTEXTMETRICA* pMetric,
    981. 

  981.                                          DWORD nFontType )
    982. 

  982. {
    983. 

  983.     int nHeight = 0;
    984. 

  984.     if ( nFontType & RASTER_FONTTYPE )
    985. 

  985.         nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
    986. 

  986. 

  987.     ImplWinFontData* pData = new ImplWinFontData(
    988. 

  988.         WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
    989. 

  989.         nHeight,
    990. 

  990.         pLogFont->elfLogFont.lfCharSet,
    991. 

  991.         pMetric->tmPitchAndFamily );
    992. 

  992. 

  993.     return pData;
    994. 

  994. }
    995. 

  995. 

  996. // -----------------------------------------------------------------------
    997. 

  997. 

  998. static ImplWinFontData* ImplLogMetricToDevFontDataW( const ENUMLOGFONTEXW* pLogFont,
    999. 

  999.                                          const NEWTEXTMETRICW* pMetric,
    1000. 

  1000.                                          DWORD nFontType )
    1001. 

  1001. {
    1002. 

  1002.     int nHeight = 0;
    1003. 

  1003.     if ( nFontType & RASTER_FONTTYPE )
    1004. 

  1004.         nHeight = pMetric->tmHeight - pMetric->tmInternalLeading;
    1005. 

  1005. 

  1006.     ImplWinFontData* pData = new ImplWinFontData(
    1007. 

  1007.         WinFont2DevFontAttributes(*pLogFont, *pMetric, nFontType),
    1008. 

  1008.         nHeight,
    1009. 

  1009.         pLogFont->elfLogFont.lfCharSet,
    1010. 

  1010.         pMetric->tmPitchAndFamily );
    1011. 

  1011. 

  1012.     return pData;
    1013. 

  1013. }
    1014. 

  1014. 

  1015. // -----------------------------------------------------------------------
    1016. 

  1016. 

  1017. void ImplSalLogFontToFontA( HDC hDC, const LOGFONTA& rLogFont, Font& rFont )
    1018. 

  1018. {
    1019. 

  1019.     String aFontName( ImplSalGetUniString( rLogFont.lfFaceName ) );
    1020. 

  1020.     if ( aFontName.Len() )
    1021. 

  1021.     {
    1022. 

  1022.         rFont.SetName( aFontName );
    1023. 

  1023.         rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
    1024. 

  1024.         rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
    1025. 

  1025.         rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
    1026. 

  1026.         rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
    1027. 

  1027. 

  1028.         long nFontHeight = rLogFont.lfHeight;
    1029. 

  1029.         if ( nFontHeight < 0 )
    1030. 

  1030.             nFontHeight = -nFontHeight;
    1031. 

  1031.         long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
    1032. 

  1032.         if( !nDPIY )
    1033. 

  1033.             nDPIY = 600;
    1034. 

  1034.         nFontHeight *= 72;
    1035. 

  1035.         nFontHeight += nDPIY/2;
    1036. 

  1036.         nFontHeight /= nDPIY;
    1037. 

  1037.         rFont.SetSize( Size( 0, nFontHeight ) );
    1038. 

  1038.         rFont.SetOrientation( (short)rLogFont.lfEscapement );
    1039. 

  1039.         if ( rLogFont.lfItalic )
    1040. 

  1040.             rFont.SetItalic( ITALIC_NORMAL );
    1041. 

  1041.         else
    1042. 

  1042.             rFont.SetItalic( ITALIC_NONE );
    1043. 

  1043.         if ( rLogFont.lfUnderline )
    1044. 

  1044.             rFont.SetUnderline( UNDERLINE_SINGLE );
    1045. 

  1045.         else
    1046. 

  1046.             rFont.SetUnderline( UNDERLINE_NONE );
    1047. 

  1047.         if ( rLogFont.lfStrikeOut )
    1048. 

  1048.             rFont.SetStrikeout( STRIKEOUT_SINGLE );
    1049. 

  1049.         else
    1050. 

  1050.             rFont.SetStrikeout( STRIKEOUT_NONE );
    1051. 

  1051.     }
    1052. 

  1052. }
    1053. 

  1053. 

  1054. // -----------------------------------------------------------------------
    1055. 

  1055. 

  1056. void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
    1057. 

  1057. {
    1058. 

  1058.     XubString aFontName( reinterpret_cast<const xub_Unicode*>(rLogFont.lfFaceName) );
    1059. 

  1059.     if ( aFontName.Len() )
    1060. 

  1060.     {
    1061. 

  1061.         rFont.SetName( aFontName );
    1062. 

  1062.         rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
    1063. 

  1063.         rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
    1064. 

  1064.         rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
    1065. 

  1065.         rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
    1066. 

  1066. 

  1067.         long nFontHeight = rLogFont.lfHeight;
    1068. 

  1068.         if ( nFontHeight < 0 )
    1069. 

  1069.             nFontHeight = -nFontHeight;
    1070. 

  1070.         long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
    1071. 

  1071.         if( !nDPIY )
    1072. 

  1072.             nDPIY = 600;
    1073. 

  1073.         nFontHeight *= 72;
    1074. 

  1074.         nFontHeight += nDPIY/2;
    1075. 

  1075.         nFontHeight /= nDPIY;
    1076. 

  1076.         rFont.SetSize( Size( 0, nFontHeight ) );
    1077. 

  1077.         rFont.SetOrientation( (short)rLogFont.lfEscapement );
    1078. 

  1078.         if ( rLogFont.lfItalic )
    1079. 

  1079.             rFont.SetItalic( ITALIC_NORMAL );
    1080. 

  1080.         else
    1081. 

  1081.             rFont.SetItalic( ITALIC_NONE );
    1082. 

  1082.         if ( rLogFont.lfUnderline )
    1083. 

  1083.             rFont.SetUnderline( UNDERLINE_SINGLE );
    1084. 

  1084.         else
    1085. 

  1085.             rFont.SetUnderline( UNDERLINE_NONE );
    1086. 

  1086.         if ( rLogFont.lfStrikeOut )
    1087. 

  1087.             rFont.SetStrikeout( STRIKEOUT_SINGLE );
    1088. 

  1088.         else
    1089. 

  1089.             rFont.SetStrikeout( STRIKEOUT_NONE );
    1090. 

  1090.     }
    1091. 

  1091. }
    1092. 

  1092. 

  1093. // =======================================================================
    1094. 

  1094. 

  1095. ImplWinFontData::ImplWinFontData( const ImplDevFontAttributes& rDFS,
    1096. 

  1096.     int nHeight, WIN_BYTE eWinCharSet, WIN_BYTE nPitchAndFamily )
    1097. 

  1097. :   ImplFontData( rDFS, 0 ),
    1098. 

  1098.     meWinCharSet( eWinCharSet ),
    1099. 

  1099.     mnPitchAndFamily( nPitchAndFamily ),
    1100. 

  1100.     mpFontCharSets( NULL ),
    1101. 

  1101.     mpUnicodeMap( NULL ),
    1102. 

  1102.     mbGsubRead( false ),
    1103. 

  1103.     mbDisableGlyphApi( false ),
    1104. 

  1104.     mbHasKoreanRange( false ),
    1105. 

  1105.     mbHasCJKSupport( false ),
    1106. 

  1106. #ifdef ENABLE_GRAPHITE
    1107. 

  1107.     mbHasGraphiteSupport( false ),
    1108. 

  1108. #endif
    1109. 

  1109.     mbHasArabicSupport ( false ),
    1110. 

  1110.     mbAliasSymbolsLow( false ),
    1111. 

  1111.     mbAliasSymbolsHigh( false ),
    1112. 

  1112.     mnId( 0 ),
    1113. 

  1113.     mpEncodingVector( NULL )
    1114. 

  1114. {
    1115. 

  1115.     SetBitmapSize( 0, nHeight );
    1116. 

  1116. 

  1117.     if( eWinCharSet == SYMBOL_CHARSET )
    1118. 

  1118.     {
    1119. 

  1119.         if( (nPitchAndFamily & TMPF_TRUETYPE) != 0 )
    1120. 

  1120.         {
    1121. 

  1121.             // truetype fonts need their symbols as U+F0xx
    1122. 

  1122.             mbAliasSymbolsHigh = true;
    1123. 

  1123.         }
    1124. 

  1124.         else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_DEVICE))
    1125. 

  1125.                                  == (TMPF_VECTOR|TMPF_DEVICE) )
    1126. 

  1126.         {
    1127. 

  1127.             // scalable device fonts (e.g. builtin printer fonts)
    1128. 

  1128.             // need their symbols as U+00xx
    1129. 

  1129.             mbAliasSymbolsLow  = true;
    1130. 

  1130.         }
    1131. 

  1131.         else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) == 0 )
    1132. 

  1132.         {
    1133. 

  1133.             // bitmap fonts need their symbols as U+F0xx
    1134. 

  1134.             mbAliasSymbolsHigh = true;
    1135. 

  1135.         }
    1136. 

  1136.     }
    1137. 

  1137. }
    1138. 

  1138. 

  1139. // -----------------------------------------------------------------------
    1140. 

  1140. 

  1141. ImplWinFontData::~ImplWinFontData()
    1142. 

  1142. {
    1143. 

  1143.     delete[] mpFontCharSets;
    1144. 

  1144. 

  1145.     if( mpUnicodeMap )
    1146. 

  1146.         mpUnicodeMap->DeReference();
    1147. 

  1147.     delete mpEncodingVector;
    1148. 

  1148. }
    1149. 

  1149. 

  1150. // -----------------------------------------------------------------------
    1151. 

  1151. 

  1152. sal_IntPtr ImplWinFontData::GetFontId() const
    1153. 

  1153. {
    1154. 

  1154.     return mnId;
    1155. 

  1155. }
    1156. 

  1156. 

  1157. // -----------------------------------------------------------------------
    1158. 

  1158. 

  1159. void ImplWinFontData::UpdateFromHDC( HDC hDC ) const
    1160. 

  1160. {
    1161. 

  1161.     // short circuit if already initialized
    1162. 

  1162.     if( mpUnicodeMap != NULL )
    1163. 

  1163.         return;
    1164. 

  1164. 

  1165.     ReadCmapTable( hDC );
    1166. 

  1166.     ReadOs2Table( hDC );
    1167. 

  1167. #ifdef ENABLE_GRAPHITE
    1168. 

  1168. 	static const char* pDisableGraphiteText = getenv( "SAL_DISABLE_GRAPHITE" );
    1169. 

  1169.     if( !pDisableGraphiteText || (pDisableGraphiteText[0] == '0') )
    1170. 

  1170. 	{
    1171. 

  1171. 		mbHasGraphiteSupport = gr::WinFont::FontHasGraphiteTables(hDC);
    1172. 

  1172. 	}
    1173. 

  1173. #endif
    1174. 

  1174. 

  1175.     // even if the font works some fonts have problems with the glyph API
    1176. 

  1176.     // => the heuristic below tries to figure out which fonts have the problem
    1177. 

  1177.     TEXTMETRICA aTextMetric;
    1178. 

  1178.     if( ::GetTextMetricsA( hDC, &aTextMetric ) )
    1179. 

  1179.         if( !(aTextMetric.tmPitchAndFamily & TMPF_TRUETYPE)
    1180. 

  1180.         ||   (aTextMetric.tmPitchAndFamily & TMPF_DEVICE) )
    1181. 

  1181.             mbDisableGlyphApi = true;
    1182. 

  1182. 

  1183. #if 0
    1184. 

  1184.     // #110548# more important than #107885# => TODO: better solution
    1185. 

  1185.     DWORD nFLI = GetFontLanguageInfo( hDC );
    1186. 

  1186.     if( 0 == (nFLI & GCP_GLYPHSHAPE) )
    1187. 

  1187.         mbDisableGlyphApi = true;
    1188. 

  1188. #endif
    1189. 

  1189. }
    1190. 

  1190. 

  1191. // -----------------------------------------------------------------------
    1192. 

  1192. 

  1193. bool ImplWinFontData::HasGSUBstitutions( HDC hDC ) const
    1194. 

  1194. {
    1195. 

  1195.     if( !mbGsubRead )
    1196. 

  1196.         ReadGsubTable( hDC );
    1197. 

  1197.     return !maGsubTable.empty();
    1198. 

  1198. }
    1199. 

  1199. 

  1200. // -----------------------------------------------------------------------
    1201. 

  1201. 

  1202. bool ImplWinFontData::IsGSUBstituted( sal_UCS4 cChar ) const
    1203. 

  1203. {
    1204. 

  1204.     return( maGsubTable.find( cChar ) != maGsubTable.end() );
    1205. 

  1205. }
    1206. 

  1206. 

  1207. // -----------------------------------------------------------------------
    1208. 

  1208. 

  1209. ImplFontCharMap* ImplWinFontData::GetImplFontCharMap() const
    1210. 

  1210. {
    1211. 

  1211.     if( !mpUnicodeMap )
    1212. 

  1212.         return NULL;
    1213. 

  1213.     mpUnicodeMap->AddReference();
    1214. 

  1214.     return mpUnicodeMap;
    1215. 

  1215. }
    1216. 

  1216. 

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

  1218. 

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

  1220. static unsigned GetUShort( const unsigned char* p ){ return((p[0]<<8)+p[1]);}
    1221. 

  1221. //static signed GetSShort( const unsigned char* p ){ return((short)((p[0]<<8)+p[1]));}
    1222. 

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

  1223. 

  1224. void ImplWinFontData::ReadOs2Table( HDC hDC ) const
    1225. 

  1225. {
    1226. 

  1226.     const DWORD Os2Tag = CalcTag( "OS/2" );
    1227. 

  1227.     DWORD nLength = ::GetFontData( hDC, Os2Tag, 0, NULL, 0 );
    1228. 

  1228.     if( (nLength == GDI_ERROR) || !nLength )
    1229. 

  1229.         return;
    1230. 

  1230.     std::vector<unsigned char> aOS2map( nLength );
    1231. 

  1231.     unsigned char* pOS2map = &aOS2map[0];
    1232. 

  1232.     ::GetFontData( hDC, Os2Tag, 0, pOS2map, nLength );
    1233. 

  1233.     sal_uInt32 nVersion = GetUShort( pOS2map );
    1234. 

  1234.     if ( nVersion >= 0x0001 && nLength >= 58 )
    1235. 

  1235.     {
    1236. 

  1236.         // We need at least version 0x0001 (TrueType rev 1.66)
    1237. 

  1237.         // to have access to the needed struct members.
    1238. 

  1238.         sal_uInt32 ulUnicodeRange1 = GetUInt( pOS2map + 42 );
    1239. 

  1239.         sal_uInt32 ulUnicodeRange2 = GetUInt( pOS2map + 46 );
    1240. 

  1240. #if 0
    1241. 

  1241.         sal_uInt32 ulUnicodeRange3 = GetUInt( pOS2map + 50 );
    1242. 

  1242.         sal_uInt32 ulUnicodeRange4 = GetUInt( pOS2map + 54 );
    1243. 

  1243. #endif
    1244. 

  1244. 

  1245.         // Check for CJK capabilities of the current font
    1246. 

  1246.         mbHasCJKSupport = (ulUnicodeRange2 & 0x2DF00000);
    1247. 

  1247.         mbHasKoreanRange= (ulUnicodeRange1 & 0x10000000)
    1248. 

  1248.                         | (ulUnicodeRange2 & 0x01100000);
    1249. 

  1249.         mbHasArabicSupport = (ulUnicodeRange1 & 0x00002000);
    1250. 

  1250.    }
    1251. 

  1251. }
    1252. 

  1252. 

  1253. // -----------------------------------------------------------------------
    1254. 

  1254. 

  1255. void ImplWinFontData::ReadGsubTable( HDC hDC ) const
    1256. 

  1256. {
    1257. 

  1257.     mbGsubRead = true;
    1258. 

  1258. 

  1259.     // check the existence of a GSUB table
    1260. 

  1260.     const DWORD GsubTag = CalcTag( "GSUB" );
    1261. 

  1261.     DWORD nRC = ::GetFontData( hDC, GsubTag, 0, NULL, 0 );
    1262. 

  1262.     if( (nRC == GDI_ERROR) || !nRC )
    1263. 

  1263.         return;
    1264. 

  1264. 

  1265. 	// parse the GSUB table through sft
    1266. 

  1266.     // TODO: parse it directly
    1267. 

  1267. 

  1268.     // sft needs the full font file data => get it
    1269. 

  1269.     const RawFontData aRawFontData( hDC );
    1270. 

  1270.     if( !aRawFontData.get() )
    1271. 

  1271.     	return;
    1272. 

  1272. 

  1273.     // open font file
    1274. 

  1274.     sal_uInt32 nFaceNum = 0;
    1275. 

  1275.     if( !*aRawFontData.get() )  // TTC candidate
    1276. 

  1276.         nFaceNum = ~0U;  // indicate "TTC font extracts only"
    1277. 

  1277. 

  1278.     TrueTypeFont* pTTFont = NULL;
    1279. 

  1279.     ::OpenTTFontBuffer( (void*)aRawFontData.get(), aRawFontData.size(), nFaceNum, &pTTFont );
    1280. 

  1280.     if( !pTTFont )
    1281. 

  1281.         return;
    1282. 

  1282. 

  1283.     // add vertically substituted characters to list
    1284. 

  1284.     static const sal_Unicode aGSUBCandidates[] = {
    1285. 

  1285.         0x0020, 0x0080, // ASCII
    1286. 

  1286.         0x2000, 0x2600, // misc
    1287. 

  1287.         0x3000, 0x3100, // CJK punctutation
    1288. 

  1288.         0x3300, 0x3400, // squared words
    1289. 

  1289.         0xFF00, 0xFFF0, // halfwidth|fullwidth forms
    1290. 

  1290.     0 };
    1291. 

  1291. 

  1292.     for( const sal_Unicode* pPair = aGSUBCandidates; *pPair; pPair += 2 )
    1293. 

  1293.         for( sal_Unicode cChar = pPair[0]; cChar < pPair[1]; ++cChar )
    1294. 

  1294.             if( ::MapChar( pTTFont, cChar, 0 ) != ::MapChar( pTTFont, cChar, 1 ) )
    1295. 

  1295.                 maGsubTable.insert( cChar ); // insert GSUBbed unicodes
    1296. 

  1296. 

  1297.     CloseTTFont( pTTFont );
    1298. 

  1298. }
    1299. 

  1299. 

  1300. // -----------------------------------------------------------------------
    1301. 

  1301. 

  1302. void ImplWinFontData::ReadCmapTable( HDC hDC ) const
    1303. 

  1303. {
    1304. 

  1304.     if( mpUnicodeMap != NULL )
    1305. 

  1305.         return;
    1306. 

  1306. 

  1307.     bool bIsSymbolFont = (meWinCharSet == SYMBOL_CHARSET);
    1308. 

  1308.     // get the CMAP table from the font which is selected into the DC
    1309. 

  1309.     const DWORD nCmapTag = CalcTag( "cmap" );
    1310. 

  1310.     const RawFontData aRawFontData( hDC, nCmapTag );
    1311. 

  1311.     // parse the CMAP table if available
    1312. 

  1312.     if( aRawFontData.get() ) {
    1313. 

  1313.         CmapResult aResult;
    1314. 

  1314.         ParseCMAP( aRawFontData.get(), aRawFontData.size(), aResult );
    1315. 

  1315.         mbDisableGlyphApi |= aResult.mbRecoded;
    1316. 

  1316.         aResult.mbSymbolic = bIsSymbolFont;
    1317. 

  1317.         if( aResult.mnRangeCount > 0 )
    1318. 

  1318.             mpUnicodeMap = new ImplFontCharMap( aResult );
    1319. 

  1319.     }
    1320. 

  1320. 

  1321.     if( !mpUnicodeMap )
    1322. 

  1322.         mpUnicodeMap = ImplFontCharMap::GetDefaultMap( bIsSymbolFont );
    1323. 

  1323. }
    1324. 

  1324. 

  1325. // =======================================================================
    1326. 

  1326. 

  1327. void WinSalGraphics::SetTextColor( SalColor nSalColor )
    1328. 

  1328. {
    1329. 

  1329.     COLORREF aCol = PALETTERGB( SALCOLOR_RED( nSalColor ),
    1330. 

  1330.                                 SALCOLOR_GREEN( nSalColor ),
    1331. 

  1331.                                 SALCOLOR_BLUE( nSalColor ) );
    1332. 

  1332. 

  1333.     if( !mbPrinter &&
    1334. 

  1334.         GetSalData()->mhDitherPal &&
    1335. 

  1335.         ImplIsSysColorEntry( nSalColor ) )
    1336. 

  1336.     {
    1337. 

  1337.         aCol = PALRGB_TO_RGB( aCol );
    1338. 

  1338.     }
    1339. 

  1339. 

  1340.     ::SetTextColor( mhDC, aCol );
    1341. 

  1341. }
    1342. 

  1342. 

  1343. // -----------------------------------------------------------------------
    1344. 

  1344. 

  1345. int CALLBACK SalEnumQueryFontProcExW( const ENUMLOGFONTEXW*,
    1346. 

  1346.                                       const NEWTEXTMETRICEXW*,
    1347. 

  1347.                                       DWORD, LPARAM lParam )
    1348. 

  1348. {
    1349. 

  1349.     *((bool*)(void*)lParam) = true;
    1350. 

  1350.     return 0;
    1351. 

  1351. }
    1352. 

  1352. 

  1353. // -----------------------------------------------------------------------
    1354. 

  1354. 

  1355. int CALLBACK SalEnumQueryFontProcExA( const ENUMLOGFONTEXA*,
    1356. 

  1356.                                       const NEWTEXTMETRICEXA*,
    1357. 

  1357.                                       DWORD, LPARAM lParam )
    1358. 

  1358. {
    1359. 

  1359.     *((bool*)(void*)lParam) = true;
    1360. 

  1360.     return 0;
    1361. 

  1361. }
    1362. 

  1362. 

  1363. // -----------------------------------------------------------------------
    1364. 

  1364. 

  1365. bool ImplIsFontAvailable( HDC hDC, const UniString& rName )
    1366. 

  1366. {
    1367. 

  1367.     bool bAvailable = false;
    1368. 

  1368. 

  1369.     if ( aSalShlData.mbWNT )
    1370. 

  1370.     {
    1371. 

  1371.         // Test, if Font available
    1372. 

  1372.         LOGFONTW aLogFont;
    1373. 

  1373.         memset( &aLogFont, 0, sizeof( aLogFont ) );
    1374. 

  1374.         aLogFont.lfCharSet = DEFAULT_CHARSET;
    1375. 

  1375. 

  1376.         UINT nNameLen = rName.Len();
    1377. 

  1377.         if ( nNameLen > (sizeof( aLogFont.lfFaceName )/sizeof( wchar_t ))-1 )
    1378. 

  1378.             nNameLen = (sizeof( aLogFont.lfFaceName )/sizeof( wchar_t ))-1;
    1379. 

  1379.         memcpy( aLogFont.lfFaceName, rName.GetBuffer(), nNameLen*sizeof( wchar_t ) );
    1380. 

  1380.         aLogFont.lfFaceName[nNameLen] = 0;
    1381. 

  1381. 

  1382.         EnumFontFamiliesExW( hDC, &aLogFont, (FONTENUMPROCW)SalEnumQueryFontProcExW,
    1383. 

  1383.                              (LPARAM)(void*)&bAvailable, 0 );
    1384. 

  1384.     }
    1385. 

  1385.     else
    1386. 

  1386.     {
    1387. 

  1387.         ByteString aTemp = ImplSalGetWinAnsiString( rName );
    1388. 

  1388. 

  1389.         // Test, if Font available
    1390. 

  1390.         LOGFONTA aLogFont;
    1391. 

  1391.         memset( &aLogFont, 0, sizeof( aLogFont ) );
    1392. 

  1392.         aLogFont.lfCharSet = DEFAULT_CHARSET;
    1393. 

  1393. 

  1394.         UINT nNameLen = aTemp.Len();
    1395. 

  1395.         if ( nNameLen > sizeof( aLogFont.lfFaceName )-1 )
    1396. 

  1396.             nNameLen = sizeof( aLogFont.lfFaceName )-1;
    1397. 

  1397.         memcpy( aLogFont.lfFaceName, aTemp.GetBuffer(), nNameLen );
    1398. 

  1398.         aLogFont.lfFaceName[nNameLen] = 0;
    1399. 

  1399. 

  1400.         EnumFontFamiliesExA( hDC, &aLogFont, (FONTENUMPROCA)SalEnumQueryFontProcExA,
    1401. 

  1401.                              (LPARAM)(void*)&bAvailable, 0 );
    1402. 

  1402.     }
    1403. 

  1403. 

  1404.     return bAvailable;
    1405. 

  1405. }
    1406. 

  1406. 

  1407. // -----------------------------------------------------------------------
    1408. 

  1408. 

  1409. void ImplGetLogFontFromFontSelect( HDC hDC,
    1410. 

  1410.                                    const ImplFontSelectData* pFont,
    1411. 

  1411.                                    LOGFONTW& rLogFont,
    1412. 

  1412.                                    bool /*bTestVerticalAvail*/ )
    1413. 

  1413. {
    1414. 

  1414.     UniString   aName;
    1415. 

  1415.     if ( pFont->mpFontData )
    1416. 

  1416.         aName = pFont->mpFontData->maName;
    1417. 

  1417.     else
    1418. 

  1418.         aName = pFont->maName.GetToken( 0 );
    1419. 

  1419. 

  1420.     UINT nNameLen = aName.Len();
    1421. 

  1421.     if ( nNameLen > (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1 )
    1422. 

  1422.         nNameLen = (sizeof( rLogFont.lfFaceName )/sizeof( wchar_t ))-1;
    1423. 

  1423.     memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen*sizeof( wchar_t ) );
    1424. 

  1424.     rLogFont.lfFaceName[nNameLen] = 0;
    1425. 

  1425. 

  1426.     if( !pFont->mpFontData )
    1427. 

  1427.     {
    1428. 

  1428.         rLogFont.lfCharSet = pFont->IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
    1429. 

  1429.         rLogFont.lfPitchAndFamily = ImplPitchToWin( pFont->mePitch )
    1430. 

  1430.                                   | ImplFamilyToWin( pFont->meFamily );
    1431. 

  1431.     }
    1432. 

  1432.     else
    1433. 

  1433.     {
    1434. 

  1434.         const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>( pFont->mpFontData );
    1435. 

  1435.         rLogFont.lfCharSet        = pWinFontData->GetCharSet();
    1436. 

  1436.         rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
    1437. 

  1437.     }
    1438. 

  1438. 

  1439.     rLogFont.lfWeight          = ImplWeightToWin( pFont->meWeight );
    1440. 

  1440.     rLogFont.lfHeight          = (LONG)-pFont->mnHeight;
    1441. 

  1441.     rLogFont.lfWidth           = (LONG)pFont->mnWidth;
    1442. 

  1442.     rLogFont.lfUnderline       = 0;
    1443. 

  1443.     rLogFont.lfStrikeOut       = 0;
    1444. 

  1444.     rLogFont.lfItalic          = (pFont->meItalic) != ITALIC_NONE;
    1445. 

  1445.     rLogFont.lfEscapement      = pFont->mnOrientation;
    1446. 

  1446.     rLogFont.lfOrientation     = rLogFont.lfEscapement;
    1447. 

  1447.     rLogFont.lfClipPrecision   = CLIP_DEFAULT_PRECIS;
    1448. 

  1448.     rLogFont.lfQuality         = DEFAULT_QUALITY;
    1449. 

  1449.     rLogFont.lfOutPrecision    = OUT_TT_PRECIS;
    1450. 

  1450.     if ( pFont->mnOrientation )
    1451. 

  1451.         rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
    1452. 

  1452. 

  1453.     // disable antialiasing if requested
    1454. 

  1454.     if ( pFont->mbNonAntialiased )
    1455. 

  1455.         rLogFont.lfQuality = NONANTIALIASED_QUALITY;
    1456. 

  1456. 

  1457.     // select vertical mode if requested and available
    1458. 

  1458.     if( pFont->mbVertical && nNameLen )
    1459. 

  1459.     {
    1460. 

  1460.         // vertical fonts start with an '@'
    1461. 

  1461.         memmove( &rLogFont.lfFaceName[1], &rLogFont.lfFaceName[0],
    1462. 

  1462.             sizeof(rLogFont.lfFaceName)-sizeof(rLogFont.lfFaceName[0]) );
    1463. 

  1463.         rLogFont.lfFaceName[0] = '@';
    1464. 

  1464. 

  1465.         // check availability of vertical mode for this font
    1466. 

  1466.         bool bAvailable = false;
    1467. 

  1467.         EnumFontFamiliesExW( hDC, &rLogFont, (FONTENUMPROCW)SalEnumQueryFontProcExW,
    1468. 

  1468.                          (LPARAM)&bAvailable, 0 );
    1469. 

  1469. 

  1470.         if( !bAvailable )
    1471. 

  1471.         {
    1472. 

  1472.             // restore non-vertical name if not vertical mode isn't available
    1473. 

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

  1474.             if( nNameLen < LF_FACESIZE )
    1475. 

  1475.                 rLogFont.lfFaceName[nNameLen] = '\0';
    1476. 

  1476.         }
    1477. 

  1477.     }
    1478. 

  1478. }
    1479. 

  1479. 

  1480. // -----------------------------------------------------------------------
    1481. 

  1481. 

  1482. static void ImplGetLogFontFromFontSelect( HDC hDC,
    1483. 

  1483.                                    const ImplFontSelectData* pFont,
    1484. 

  1484.                                    LOGFONTA& rLogFont,
    1485. 

  1485.                                    bool /*bTestVerticalAvail*/ )
    1486. 

  1486. {
    1487. 

  1487.     ByteString aName;
    1488. 

  1488.     if( pFont->mpFontData )
    1489. 

  1489.         aName = ImplSalGetWinAnsiString( pFont->mpFontData->maName );
    1490. 

  1490.     else
    1491. 

  1491.         aName = ImplSalGetWinAnsiString( pFont->maName.GetToken( 0 ) );
    1492. 

  1492. 

  1493.     int nNameLen = aName.Len();
    1494. 

  1494.     if( nNameLen > LF_FACESIZE )
    1495. 

  1495.         nNameLen = LF_FACESIZE;
    1496. 

  1496.     memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen );
    1497. 

  1497.     if( nNameLen < LF_FACESIZE )
    1498. 

  1498.         rLogFont.lfFaceName[nNameLen] = '\0';
    1499. 

  1499. 

  1500.     if( !pFont->mpFontData )
    1501. 

  1501.     {
    1502. 

  1502.         rLogFont.lfCharSet = pFont->IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
    1503. 

  1503.         rLogFont.lfPitchAndFamily = ImplPitchToWin( pFont->mePitch )
    1504. 

  1504.                                   | ImplFamilyToWin( pFont->meFamily );
    1505. 

  1505.     }
    1506. 

  1506.     else
    1507. 

  1507.     {
    1508. 

  1508.         const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>( pFont->mpFontData );
    1509. 

  1509.         rLogFont.lfCharSet        = pWinFontData->GetCharSet();
    1510. 

  1510.         rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
    1511. 

  1511.     }
    1512. 

  1512. 

  1513.     rLogFont.lfWeight           = ImplWeightToWin( pFont->meWeight );
    1514. 

  1514.     rLogFont.lfHeight           = (LONG)-pFont->mnHeight;
    1515. 

  1515.     rLogFont.lfWidth            = (LONG)pFont->mnWidth;
    1516. 

  1516.     rLogFont.lfUnderline        = 0;
    1517. 

  1517.     rLogFont.lfStrikeOut        = 0;
    1518. 

  1518.     rLogFont.lfItalic           = (pFont->meItalic) != ITALIC_NONE;
    1519. 

  1519.     rLogFont.lfEscapement       = pFont->mnOrientation;
    1520. 

  1520.     rLogFont.lfOrientation      = rLogFont.lfEscapement; // ignored by W98
    1521. 

  1521.     rLogFont.lfClipPrecision    = CLIP_DEFAULT_PRECIS;
    1522. 

  1522.     rLogFont.lfQuality          = DEFAULT_QUALITY;
    1523. 

  1523.     rLogFont.lfOutPrecision     = OUT_TT_PRECIS;
    1524. 

  1524.     if( pFont->mnOrientation )
    1525. 

  1525.         rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
    1526. 

  1526. 

  1527.     // disable antialiasing if requested
    1528. 

  1528.     if( pFont->mbNonAntialiased )
    1529. 

  1529.         rLogFont.lfQuality = NONANTIALIASED_QUALITY;
    1530. 

  1530. 

  1531.     // select vertical mode if requested and available
    1532. 

  1532.     if( pFont->mbVertical && nNameLen )
    1533. 

  1533.     {
    1534. 

  1534.         // vertical fonts start with an '@'
    1535. 

  1535.         memmove( &rLogFont.lfFaceName[1], &rLogFont.lfFaceName[0],
    1536. 

  1536.                     sizeof(rLogFont.lfFaceName)-sizeof(rLogFont.lfFaceName[0]) );
    1537. 

  1537.         rLogFont.lfFaceName[0] = '@';
    1538. 

  1538. 

  1539.         // check availability of vertical mode for this font
    1540. 

  1540.         bool bAvailable = false;
    1541. 

  1541.         EnumFontFamiliesExA( hDC, &rLogFont, (FONTENUMPROCA)SalEnumQueryFontProcExA,
    1542. 

  1542.                          (LPARAM)&bAvailable, 0 );
    1543. 

  1543. 

  1544.         if( !bAvailable )
    1545. 

  1545.         {
    1546. 

  1546.             // restore non-vertical name if vertical mode is not supported
    1547. 

  1547.             memcpy( rLogFont.lfFaceName, aName.GetBuffer(), nNameLen );
    1548. 

  1548.             if( nNameLen < LF_FACESIZE )
    1549. 

  1549.                 rLogFont.lfFaceName[nNameLen] = '\0';
    1550. 

  1550.         }
    1551. 

  1551.     }
    1552. 

  1552. }
    1553. 

  1553. 

  1554. // -----------------------------------------------------------------------
    1555. 

  1555. 

  1556. HFONT WinSalGraphics::ImplDoSetFont( ImplFontSelectData* i_pFont, float& o_rFontScale, HFONT& o_rOldFont )
    1557. 

  1557. {
    1558. 

  1558.     HFONT hNewFont = 0;
    1559. 

  1559. 

  1560.     HDC hdcScreen = 0;
    1561. 

  1561.     if( mbVirDev )
    1562. 

  1562.         // only required for virtual devices, see below for details
    1563. 

  1563.         hdcScreen = GetDC(0);
    1564. 

  1564. 

  1565.     if( aSalShlData.mbWNT )
    1566. 

  1566.     {
    1567. 

  1567.         LOGFONTW aLogFont;
    1568. 

  1568.         ImplGetLogFontFromFontSelect( mhDC, i_pFont, aLogFont, true );
    1569. 

  1569. 

  1570.         // on the display we prefer Courier New when Courier is a
    1571. 

  1571.         // bitmap only font and we need to stretch or rotate it
    1572. 

  1572.         if( mbScreen
    1573. 

  1573.         &&  (i_pFont->mnWidth != 0
    1574. 

  1574.           || i_pFont->mnOrientation != 0
    1575. 

  1575.           || i_pFont->mpFontData == NULL
    1576. 

  1576.           || (i_pFont->mpFontData->GetHeight() != i_pFont->mnHeight))
    1577. 

  1577.         && !bImplSalCourierScalable
    1578. 

  1578.         && bImplSalCourierNew
    1579. 

  1579.         && (ImplSalWICompareAscii( aLogFont.lfFaceName, "Courier" ) == 0) )
    1580. 

  1580.             lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
    1581. 

  1581. 

  1582.         // #i47675# limit font requests to MAXFONTHEIGHT
    1583. 

  1583.         // TODO: share MAXFONTHEIGHT font instance
    1584. 

  1584.         if( (-aLogFont.lfHeight <= MAXFONTHEIGHT)
    1585. 

  1585.         &&  (+aLogFont.lfWidth <= MAXFONTHEIGHT) )
    1586. 

  1586.         {
    1587. 

  1587.             o_rFontScale = 1.0;
    1588. 

  1588.         }
    1589. 

  1589.         else if( -aLogFont.lfHeight >= +aLogFont.lfWidth )
    1590. 

  1590.         {
    1591. 

  1591.             o_rFontScale = -aLogFont.lfHeight / (float)MAXFONTHEIGHT;
    1592. 

  1592.             aLogFont.lfHeight = -MAXFONTHEIGHT;
    1593. 

  1593.             aLogFont.lfWidth = FRound( aLogFont.lfWidth / o_rFontScale );
    1594. 

  1594.         }
    1595. 

  1595.         else // #i95867# also limit font widths
    1596. 

  1596.         {
    1597. 

  1597.             o_rFontScale = +aLogFont.lfWidth / (float)MAXFONTHEIGHT;
    1598. 

  1598.             aLogFont.lfWidth = +MAXFONTHEIGHT;
    1599. 

  1599.             aLogFont.lfHeight = FRound( aLogFont.lfHeight / o_rFontScale );
    1600. 

  1600.         }
    1601. 

  1601. 

  1602.         hNewFont = ::CreateFontIndirectW( &aLogFont );
    1603. 

  1603.         if( hdcScreen )
    1604. 

  1604.         {
    1605. 

  1605.             // select font into screen hdc first to get an antialiased font
    1606. 

  1606.             // see knowledge base article 305290:
    1607. 

  1607.             // "PRB: Fonts Not Drawn Antialiased on Device Context for DirectDraw Surface"
    1608. 

  1608.             SelectFont( hdcScreen, SelectFont( hdcScreen , hNewFont ) );
    1609. 

  1609.         }
    1610. 

  1610.         o_rOldFont = ::SelectFont( mhDC, hNewFont );
    1611. 

  1611. 

  1612.         TEXTMETRICW aTextMetricW;
    1613. 

  1613.         if( !::GetTextMetricsW( mhDC, &aTextMetricW ) )
    1614. 

  1614.         {
    1615. 

  1615.             // the selected font doesn't work => try a replacement
    1616. 

  1616.             // TODO: use its font fallback instead
    1617. 

  1617.             lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
    1618. 

  1618.             aLogFont.lfPitchAndFamily = FIXED_PITCH;
    1619. 

  1619.             HFONT hNewFont2 = CreateFontIndirectW( &aLogFont );
    1620. 

  1620.             SelectFont( mhDC, hNewFont2 );
    1621. 

  1621.             DeleteFont( hNewFont );
    1622. 

  1622.             hNewFont = hNewFont2;
    1623. 

  1623.         }
    1624. 

  1624.     }
    1625. 

  1625.     else
    1626. 

  1626.     {
    1627. 

  1627.         if( !mpLogFont )
    1628. 

  1628.              // mpLogFont is needed for getting the kerning pairs
    1629. 

  1629.              // TODO: get them from somewhere else
    1630. 

  1630.             mpLogFont = new LOGFONTA;
    1631. 

  1631.         LOGFONTA& aLogFont = *mpLogFont;
    1632. 

  1632.         ImplGetLogFontFromFontSelect( mhDC, i_pFont, aLogFont, true );
    1633. 

  1633. 

  1634.         // on the display we prefer Courier New when Courier is a
    1635. 

  1635.         // bitmap only font and we need to stretch or rotate it
    1636. 

  1636.         if( mbScreen
    1637. 

  1637.         &&  (i_pFont->mnWidth != 0
    1638. 

  1638.           || i_pFont->mnOrientation != 0
    1639. 

  1639.           || i_pFont->mpFontData == NULL
    1640. 

  1640.           || (i_pFont->mpFontData->GetHeight() != i_pFont->mnHeight))
    1641. 

  1641.         && !bImplSalCourierScalable
    1642. 

  1642.         && bImplSalCourierNew
    1643. 

  1643.         && (stricmp( aLogFont.lfFaceName, "Courier" ) == 0) )
    1644. 

  1644.             strncpy( aLogFont.lfFaceName, "Courier New", 11 );
    1645. 

  1645. 

  1646.         // limit font requests to MAXFONTHEIGHT to work around driver problems
    1647. 

  1647.         // TODO: share MAXFONTHEIGHT font instance
    1648. 

  1648.         if( -aLogFont.lfHeight <= MAXFONTHEIGHT )
    1649. 

  1649.             o_rFontScale = 1.0;
    1650. 

  1650.         else
    1651. 

  1651.         {
    1652. 

  1652.             o_rFontScale = -aLogFont.lfHeight / (float)MAXFONTHEIGHT;
    1653. 

  1653.             aLogFont.lfHeight = -MAXFONTHEIGHT;
    1654. 

  1654.             aLogFont.lfWidth = static_cast<LONG>( aLogFont.lfWidth / o_rFontScale );
    1655. 

  1655.         }
    1656. 

  1656. 

  1657.         hNewFont = ::CreateFontIndirectA( &aLogFont );
    1658. 

  1658.         if( hdcScreen )
    1659. 

  1659.         {
    1660. 

  1660.             // select font into screen hdc first to get an antialiased font
    1661. 

  1661.             // see knowledge base article 305290:
    1662. 

  1662.             // "PRB: Fonts Not Drawn Antialiased on Device Context for DirectDraw Surface"
    1663. 

  1663.             ::SelectFont( hdcScreen, ::SelectFont( hdcScreen , hNewFont ) );
    1664. 

  1664.         }
    1665. 

  1665.         o_rOldFont = ::SelectFont( mhDC, hNewFont );
    1666. 

  1666. 

  1667.         TEXTMETRICA aTextMetricA;
    1668. 

  1668.         // when the font doesn't work try a replacement
    1669. 

  1669.         if ( !::GetTextMetricsA( mhDC, &aTextMetricA ) )
    1670. 

  1670.         {
    1671. 

  1671.             // the selected font doesn't work => try a replacement
    1672. 

  1672.             // TODO: use its font fallback instead
    1673. 

  1673.             LOGFONTA aTempLogFont = aLogFont;
    1674. 

  1674.             strncpy( aTempLogFont.lfFaceName, "Courier New", 11 );
    1675. 

  1675.             aTempLogFont.lfPitchAndFamily = FIXED_PITCH;
    1676. 

  1676.             HFONT hNewFont2 = CreateFontIndirectA( &aTempLogFont );
    1677. 

  1677.             ::SelectFont( mhDC, hNewFont2 );
    1678. 

  1678.             ::DeleteFont( hNewFont );
    1679. 

  1679.             hNewFont = hNewFont2;
    1680. 

  1680.         }
    1681. 

  1681.     }
    1682. 

  1682. 

  1683.     if( hdcScreen )
    1684. 

  1684.         ::ReleaseDC( NULL, hdcScreen );
    1685. 

  1685. 

  1686.     return hNewFont;
    1687. 

  1687. }
    1688. 

  1688. 

  1689. USHORT WinSalGraphics::SetFont( ImplFontSelectData* pFont, int nFallbackLevel )
    1690. 

  1690. {
    1691. 

  1691.     // return early if there is no new font
    1692. 

  1692.     if( !pFont )
    1693. 

  1693.     {
    1694. 

  1694.         // deselect still active font
    1695. 

  1695.         if( mhDefFont )
    1696. 

  1696.             ::SelectFont( mhDC, mhDefFont );
    1697. 

  1697.         // release no longer referenced font handles
    1698. 

  1698.         for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
    1699. 

  1699.         {
    1700. 

  1700.             if( mhFonts[i] )
    1701. 

  1701.                 ::DeleteFont( mhFonts[i] );
    1702. 

  1702.             mhFonts[ i ] = 0;
    1703. 

  1703.         }
    1704. 

  1704.         mhDefFont = 0;
    1705. 

  1705.         return 0;
    1706. 

  1706.     }
    1707. 

  1707. 

  1708.     DBG_ASSERT( pFont->mpFontData, "WinSalGraphics mpFontData==NULL");
    1709. 

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

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

  1711. 

  1712.     HFONT hOldFont = 0;
    1713. 

  1713.     HFONT hNewFont = ImplDoSetFont( pFont, mfFontScale, hOldFont );
    1714. 

  1714. 

  1715.     if( !mhDefFont )
    1716. 

  1716.     {
    1717. 

  1717.         // keep default font
    1718. 

  1718.         mhDefFont = hOldFont;
    1719. 

  1719.     }
    1720. 

  1720.     else
    1721. 

  1721.     {
    1722. 

  1722.         // release no longer referenced font handles
    1723. 

  1723.         for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
    1724. 

  1724.         {
    1725. 

  1725.             if( mhFonts[i] )
    1726. 

  1726.             {
    1727. 

  1727.                 ::DeleteFont( mhFonts[i] );
    1728. 

  1728.                 mhFonts[i] = 0;
    1729. 

  1729.             }
    1730. 

  1730.         }
    1731. 

  1731.     }
    1732. 

  1732. 

  1733.     // store new font in correct layer
    1734. 

  1734.     mhFonts[ nFallbackLevel ] = hNewFont;
    1735. 

  1735.     // now the font is live => update font face
    1736. 

  1736.     if( mpWinFontData[ nFallbackLevel ] )
    1737. 

  1737.         mpWinFontData[ nFallbackLevel ]->UpdateFromHDC( mhDC );
    1738. 

  1738. 

  1739.     if( !nFallbackLevel )
    1740. 

  1740.     {
    1741. 

  1741.         mbFontKernInit = TRUE;
    1742. 

  1742.         if ( mpFontKernPairs )
    1743. 

  1743.         {
    1744. 

  1744.             delete[] mpFontKernPairs;
    1745. 

  1745.             mpFontKernPairs = NULL;
    1746. 

  1746.         }
    1747. 

  1747.         mnFontKernPairCount = 0;
    1748. 

  1748.     }
    1749. 

  1749. 

  1750.     mnFontCharSetCount = 0;
    1751. 

  1751. 

  1752.     // some printers have higher internal resolution, so their
    1753. 

  1753.     // text output would be different from what we calculated
    1754. 

  1754.     // => suggest DrawTextArray to workaround this problem
    1755. 

  1755.     if ( mbPrinter )
    1756. 

  1756.         return SAL_SETFONT_USEDRAWTEXTARRAY;
    1757. 

  1757.     else
    1758. 

  1758.         return 0;
    1759. 

  1759. }
    1760. 

  1760. 

  1761. // -----------------------------------------------------------------------
    1762. 

  1762. 

  1763. void WinSalGraphics::GetFontMetric( ImplFontMetricData* pMetric )
    1764. 

  1764. {
    1765. 

  1765.     if ( aSalShlData.mbWNT )
    1766. 

  1766.     {
    1767. 

  1767.         wchar_t aFaceName[LF_FACESIZE+60];
    1768. 

  1768.         if( ::GetTextFaceW( mhDC, sizeof(aFaceName)/sizeof(wchar_t), aFaceName ) )
    1769. 

  1769.             pMetric->maName = reinterpret_cast<const sal_Unicode*>(aFaceName);
    1770. 

  1770.     }
    1771. 

  1771.     else
    1772. 

  1772.     {
    1773. 

  1773.         char aFaceName[LF_FACESIZE+60];
    1774. 

  1774.         if( ::GetTextFaceA( mhDC, sizeof(aFaceName), aFaceName ) )
    1775. 

  1775.             pMetric->maName = ImplSalGetUniString( aFaceName );
    1776. 

  1776.     }
    1777. 

  1777. 

  1778.     TEXTMETRICA aWinMetric;
    1779. 

  1779.     if( !GetTextMetricsA( mhDC, &aWinMetric ) )
    1780. 

  1780.         return;
    1781. 

  1781. 

  1782.     // device independent font attributes
    1783. 

  1783.     pMetric->meFamily       = ImplFamilyToSal( aWinMetric.tmPitchAndFamily );;
    1784. 

  1784.     pMetric->mbSymbolFlag   = (aWinMetric.tmCharSet == SYMBOL_CHARSET);
    1785. 

  1785.     pMetric->meWeight       = ImplWeightToSal( aWinMetric.tmWeight );
    1786. 

  1786.     pMetric->mePitch        = ImplMetricPitchToSal( aWinMetric.tmPitchAndFamily );
    1787. 

  1787.     pMetric->meItalic       = aWinMetric.tmItalic ? ITALIC_NORMAL : ITALIC_NONE;
    1788. 

  1788.     pMetric->mnSlant        = 0;
    1789. 

  1789. 

  1790.     // device dependend font attributes
    1791. 

  1791.     pMetric->mbDevice       = (aWinMetric.tmPitchAndFamily & TMPF_DEVICE) != 0;
    1792. 

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

  1793.     if( pMetric->mbScalableFont )
    1794. 

  1794.     {
    1795. 

  1795.         // check if there are kern pairs
    1796. 

  1796.         // TODO: does this work with GPOS kerning?
    1797. 

  1797.         DWORD nKernPairs = ::GetKerningPairsA( mhDC, 0, NULL );
    1798. 

  1798.         pMetric->mbKernableFont = (nKernPairs > 0);
    1799. 

  1799.     }
    1800. 

  1800.     else
    1801. 

  1801.     {
    1802. 

  1802.         // bitmap fonts cannot be rotated directly
    1803. 

  1803.         pMetric->mnOrientation  = 0;
    1804. 

  1804.         // bitmap fonts have no kerning
    1805. 

  1805.         pMetric->mbKernableFont = false;
    1806. 

  1806.     }
    1807. 

  1807. 

  1808.     // transformation dependend font metrics
    1809. 

  1809.     pMetric->mnWidth        = static_cast<int>( mfFontScale * aWinMetric.tmAveCharWidth );
    1810. 

  1810.     pMetric->mnIntLeading   = static_cast<int>( mfFontScale * aWinMetric.tmInternalLeading );
    1811. 

  1811.     pMetric->mnExtLeading   = static_cast<int>( mfFontScale * aWinMetric.tmExternalLeading );
    1812. 

  1812.     pMetric->mnAscent       = static_cast<int>( mfFontScale * aWinMetric.tmAscent );
    1813. 

  1813.     pMetric->mnDescent      = static_cast<int>( mfFontScale * aWinMetric.tmDescent );
    1814. 

  1814. 

  1815.     // #107888# improved metric compatibility for Asian fonts...
    1816. 

  1816.     // TODO: assess workaround below for CWS >= extleading
    1817. 

  1817.     // TODO: evaluate use of aWinMetric.sTypo* members for CJK
    1818. 

  1818.     if( mpWinFontData[0] && mpWinFontData[0]->SupportsCJK() )
    1819. 

  1819.     {
    1820. 

  1820.         pMetric->mnIntLeading += pMetric->mnExtLeading;
    1821. 

  1821. 

  1822.         // #109280# The line height for Asian fonts is too small.
    1823. 

  1823.         // Therefore we add half of the external leading to the
    1824. 

  1824.         // ascent, the other half is added to the descent.
    1825. 

  1825.         const long nHalfTmpExtLeading = pMetric->mnExtLeading / 2;
    1826. 

  1826.         const long nOtherHalfTmpExtLeading = pMetric->mnExtLeading - nHalfTmpExtLeading;
    1827. 

  1827. 

  1828.         // #110641# external leading for Asian fonts.
    1829. 

  1829.         // The factor 0.3 has been confirmed with experiments.
    1830. 

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

  1831.         nCJKExtLeading -= pMetric->mnExtLeading;
    1832. 

  1832.         pMetric->mnExtLeading = (nCJKExtLeading > 0) ? nCJKExtLeading : 0;
    1833. 

  1833. 

  1834.         pMetric->mnAscent   += nHalfTmpExtLeading;
    1835. 

  1835.         pMetric->mnDescent  += nOtherHalfTmpExtLeading;
    1836. 

  1836. 

  1837.         // #109280# HACK korean only: increase descent for wavelines and impr
    1838. 

  1838.         if( !aSalShlData.mbWNT )
    1839. 

  1839.             if( mpWinFontData[0]->SupportsKorean() )
    1840. 

  1840.                 pMetric->mnDescent += pMetric->mnExtLeading;
    1841. 

  1841.     }
    1842. 

  1842. 

  1843.     pMetric->mnMinKashida = GetMinKashidaWidth();
    1844. 

  1844. }
    1845. 

  1845. 

  1846. // -----------------------------------------------------------------------
    1847. 

  1847. 

  1848. int CALLBACK SalEnumCharSetsProcExA( const ENUMLOGFONTEXA* pLogFont,
    1849. 

  1849.                                      const NEWTEXTMETRICEXA* /*pMetric*/,
    1850. 

  1850.                                      DWORD /*nFontType*/, LPARAM lParam )
    1851. 

  1851. {
    1852. 

  1852.     WinSalGraphics* pData = (WinSalGraphics*)lParam;
    1853. 

  1853.     // Charset already in the list?
    1854. 

  1854.     for ( BYTE i = 0; i < pData->mnFontCharSetCount; i++ )
    1855. 

  1855.     {
    1856. 

  1856.         if ( pData->mpFontCharSets[i] == pLogFont->elfLogFont.lfCharSet )
    1857. 

  1857.             return 1;
    1858. 

  1858.     }
    1859. 

  1859.     pData->mpFontCharSets[pData->mnFontCharSetCount] = pLogFont->elfLogFont.lfCharSet;
    1860. 

  1860.     pData->mnFontCharSetCount++;
    1861. 

  1861.     return 1;
    1862. 

  1862. }
    1863. 

  1863. 

  1864. // -----------------------------------------------------------------------
    1865. 

  1865. 

  1866. static void ImplGetAllFontCharSets( WinSalGraphics* pData )
    1867. 

  1867. {
    1868. 

  1868.     if ( !pData->mpFontCharSets )
    1869. 

  1869.         pData->mpFontCharSets = new BYTE[256];
    1870. 

  1870. 

  1871.     LOGFONTA aLogFont;
    1872. 

  1872.     memset( &aLogFont, 0, sizeof( aLogFont ) );
    1873. 

  1873.     aLogFont.lfCharSet = DEFAULT_CHARSET;
    1874. 

  1874.     GetTextFaceA( pData->mhDC, sizeof( aLogFont.lfFaceName ), aLogFont.lfFaceName );
    1875. 

  1875.     EnumFontFamiliesExA( pData->mhDC, &aLogFont, (FONTENUMPROCA)SalEnumCharSetsProcExA,
    1876. 

  1876.                          (LPARAM)(void*)pData, 0 );
    1877. 

  1877. }
    1878. 

  1878. 

  1879. // -----------------------------------------------------------------------
    1880. 

  1880. 

  1881. static void ImplAddKerningPairs( WinSalGraphics* pData )
    1882. 

  1882. {
    1883. 

  1883.     ULONG nPairs = ::GetKerningPairsA( pData->mhDC, 0, NULL );
    1884. 

  1884.     if ( !nPairs )
    1885. 

  1885.         return;
    1886. 

  1886. 

  1887.     CHARSETINFO aInfo;
    1888. 

  1888.     if ( !TranslateCharsetInfo( (DWORD*)(ULONG)GetTextCharset( pData->mhDC ), &aInfo, TCI_SRCCHARSET ) )
    1889. 

  1889.         return;
    1890. 

  1890. 

  1891.     if ( !pData->mpFontKernPairs )
    1892. 

  1892.         pData->mpFontKernPairs = new KERNINGPAIR[nPairs];
    1893. 

  1893.     else
    1894. 

  1894.     {
    1895. 

  1895.         KERNINGPAIR* pOldPairs = pData->mpFontKernPairs;
    1896. 

  1896.         pData->mpFontKernPairs = new KERNINGPAIR[nPairs+pData->mnFontKernPairCount];
    1897. 

  1897.         memcpy( pData->mpFontKernPairs, pOldPairs,
    1898. 

  1898.                 pData->mnFontKernPairCount*sizeof( KERNINGPAIR ) );
    1899. 

  1899.         delete[] pOldPairs;
    1900. 

  1900.     }
    1901. 

  1901. 

  1902.     UINT            nCP = aInfo.ciACP;
    1903. 

  1903.     ULONG           nOldPairs = pData->mnFontKernPairCount;
    1904. 

  1904.     KERNINGPAIR*    pTempPair = pData->mpFontKernPairs+pData->mnFontKernPairCount;
    1905. 

  1905.     nPairs = ::GetKerningPairsA( pData->mhDC, nPairs, pTempPair );
    1906. 

  1906.     for ( ULONG i = 0; i < nPairs; i++ )
    1907. 

  1907.     {
    1908. 

  1908.         unsigned char   aBuf[2];
    1909. 

  1909.         wchar_t         nChar;
    1910. 

  1910.         int             nLen;
    1911. 

  1911.         BOOL            bAdd = TRUE;
    1912. 

  1912. 

  1913.         // None-ASCII?, then we must convert the char
    1914. 

  1914.         if ( (pTempPair->wFirst > 125) || (pTempPair->wFirst == 92) )
    1915. 

  1915.         {
    1916. 

  1916.             if ( pTempPair->wFirst < 256 )
    1917. 

  1917.             {
    1918. 

  1918.                 aBuf[0] = (unsigned char)pTempPair->wFirst;
    1919. 

  1919.                 nLen = 1;
    1920. 

  1920.             }
    1921. 

  1921.             else
    1922. 

  1922.             {
    1923. 

  1923.                 aBuf[0] = (unsigned char)(pTempPair->wFirst >> 8);
    1924. 

  1924.                 aBuf[1] = (unsigned char)(pTempPair->wFirst & 0xFF);
    1925. 

  1925.                 nLen = 2;
    1926. 

  1926.             }
    1927. 

  1927.             if ( MultiByteToWideChar( nCP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
    1928. 

  1928.                                       (const char*)aBuf, nLen, &nChar, 1 ) )
    1929. 

  1929.                 pTempPair->wFirst = nChar;
    1930. 

  1930.             else
    1931. 

  1931.                 bAdd = FALSE;
    1932. 

  1932.         }
    1933. 

  1933.         if ( (pTempPair->wSecond > 125) || (pTempPair->wSecond == 92) )
    1934. 

  1934.         {
    1935. 

  1935.             if ( pTempPair->wSecond < 256 )
    1936. 

  1936.             {
    1937. 

  1937.                 aBuf[0] = (unsigned char)pTempPair->wSecond;
    1938. 

  1938.                 nLen = 1;
    1939. 

  1939.             }
    1940. 

  1940.             else
    1941. 

  1941.             {
    1942. 

  1942.                 aBuf[0] = (unsigned char)(pTempPair->wSecond >> 8);
    1943. 

  1943.                 aBuf[1] = (unsigned char)(pTempPair->wSecond & 0xFF);
    1944. 

  1944.                 nLen = 2;
    1945. 

  1945.             }
    1946. 

  1946.             if ( MultiByteToWideChar( nCP, MB_PRECOMPOSED | MB_USEGLYPHCHARS,
    1947. 

  1947.                                       (const char*)aBuf, nLen, &nChar, 1 ) )
    1948. 

  1948.                 pTempPair->wSecond = nChar;
    1949. 

  1949.             else
    1950. 

  1950.                 bAdd = FALSE;
    1951. 

  1951.         }
    1952. 

  1952. 

  1953.         // TODO: get rid of linear search!
    1954. 

  1954.         KERNINGPAIR* pTempPair2 = pData->mpFontKernPairs;
    1955. 

  1955.         for ( ULONG j = 0; j < nOldPairs; j++ )
    1956. 

  1956.         {
    1957. 

  1957.             if ( (pTempPair2->wFirst == pTempPair->wFirst) &&
    1958. 

  1958.                  (pTempPair2->wSecond == pTempPair->wSecond) )
    1959. 

  1959.             {
    1960. 

  1960.                 bAdd = FALSE;
    1961. 

  1961.                 break;
    1962. 

  1962.             }
    1963. 

  1963.             pTempPair2++;
    1964. 

  1964.         }
    1965. 

  1965. 

  1966.         if ( bAdd )
    1967. 

  1967.         {
    1968. 

  1968.             KERNINGPAIR* pDestPair = pData->mpFontKernPairs+pData->mnFontKernPairCount;
    1969. 

  1969.             if ( pDestPair != pTempPair )
    1970. 

  1970.                 memcpy( pDestPair, pTempPair, sizeof( KERNINGPAIR ) );
    1971. 

  1971.             pData->mnFontKernPairCount++;
    1972. 

  1972.         }
    1973. 

  1973. 

  1974.         pTempPair++;
    1975. 

  1975.     }
    1976. 

  1976. }
    1977. 

  1977. 

  1978. // -----------------------------------------------------------------------
    1979. 

  1979. 

  1980. ULONG WinSalGraphics::GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs )
    1981. 

  1981. {
    1982. 

  1982.     DBG_ASSERT( sizeof( KERNINGPAIR ) == sizeof( ImplKernPairData ),
    1983. 

  1983.                 "WinSalGraphics::GetKernPairs(): KERNINGPAIR != ImplKernPairData" );
    1984. 

  1984. 

  1985.     if ( mbFontKernInit )
    1986. 

  1986.     {
    1987. 

  1987.         if( mpFontKernPairs )
    1988. 

  1988.         {
    1989. 

  1989.             delete[] mpFontKernPairs;
    1990. 

  1990.             mpFontKernPairs = NULL;
    1991. 

  1991.         }
    1992. 

  1992.         mnFontKernPairCount = 0;
    1993. 

  1993. 

  1994.         if ( aSalShlData.mbWNT )
    1995. 

  1995.         {
    1996. 

  1996.             KERNINGPAIR* pPairs = NULL;
    1997. 

  1997.             int nCount = ::GetKerningPairsW( mhDC, 0, NULL );
    1998. 

  1998.             if( nCount )
    1999. 

  1999.             {
    2000. 

  2000. #ifdef GCP_KERN_HACK
    2001. 

  2001.                 pPairs = new KERNINGPAIR[ nCount+1 ];
    2002. 

  2002.                 mpFontKernPairs = pPairs;
    2003. 

  2003.                 mnFontKernPairCount = nCount;
    2004. 

  2004.                 ::GetKerningPairsW( mhDC, nCount, pPairs );
    2005. 

  2005. #else // GCP_KERN_HACK
    2006. 

  2006.                 pPairs = pKernPairs;
    2007. 

  2007.                 nCount = (nCount < nPairs) : nCount : nPairs;
    2008. 

  2008.                 ::GetKerningPairsW( mhDC, nCount, pPairs );
    2009. 

  2009.                 return nCount;
    2010. 

  2010. #endif // GCP_KERN_HACK
    2011. 

  2011.             }
    2012. 

  2012.         }
    2013. 

  2013.         else
    2014. 

  2014.         {
    2015. 

  2015.             if ( !mnFontCharSetCount )
    2016. 

  2016.                 ImplGetAllFontCharSets( this );
    2017. 

  2017. 

  2018.             if ( mnFontCharSetCount <= 1 )
    2019. 

  2019.                 ImplAddKerningPairs( this );
    2020. 

  2020.             else
    2021. 

  2021.             {
    2022. 

  2022.                 // Query All Kerning Pairs from all possible CharSets
    2023. 

  2023.                 for ( BYTE i = 0; i < mnFontCharSetCount; i++ )
    2024. 

  2024.                 {
    2025. 

  2025.                     mpLogFont->lfCharSet = mpFontCharSets[i];
    2026. 

  2026.                     HFONT hNewFont = CreateFontIndirectA( mpLogFont );
    2027. 

  2027.                     HFONT hOldFont = SelectFont( mhDC, hNewFont );
    2028. 

  2028.                     ImplAddKerningPairs( this );
    2029. 

  2029.                     SelectFont( mhDC, hOldFont );
    2030. 

  2030.                     DeleteFont( hNewFont );
    2031. 

  2031.                 }
    2032. 

  2032.             }
    2033. 

  2033.         }
    2034. 

  2034. 

  2035.         mbFontKernInit = FALSE;
    2036. 

  2036. 

  2037.         std::sort( mpFontKernPairs, mpFontKernPairs + mnFontKernPairCount, ImplCmpKernData );
    2038. 

  2038.     }
    2039. 

  2039. 

  2040.     if( !pKernPairs )
    2041. 

  2041.         return mnFontKernPairCount;
    2042. 

  2042.     else if( mpFontKernPairs )
    2043. 

  2043.     {
    2044. 

  2044.         if ( nPairs < mnFontKernPairCount )
    2045. 

  2045.             nPairs = mnFontKernPairCount;
    2046. 

  2046.         memcpy( pKernPairs, mpFontKernPairs,
    2047. 

  2047.                 nPairs*sizeof( ImplKernPairData ) );
    2048. 

  2048.         return nPairs;
    2049. 

  2049.     }
    2050. 

  2050. 

  2051.     return 0;
    2052. 

  2052. }
    2053. 

  2053. 

  2054. // -----------------------------------------------------------------------
    2055. 

  2055. 

  2056. ImplFontCharMap* WinSalGraphics::GetImplFontCharMap() const
    2057. 

  2057. {
    2058. 

  2058.     if( !mpWinFontData[0] )
    2059. 

  2059.         return ImplFontCharMap::GetDefaultMap();
    2060. 

  2060.     return mpWinFontData[0]->GetImplFontCharMap();
    2061. 

  2061. }
    2062. 

  2062. 

  2063. // -----------------------------------------------------------------------
    2064. 

  2064. 

  2065. int CALLBACK SalEnumFontsProcExA( const ENUMLOGFONTEXA* pLogFont,
    2066. 

  2066.                                   const NEWTEXTMETRICEXA* pMetric,
    2067. 

  2067.                                   DWORD nFontType, LPARAM lParam )
    2068. 

  2068. {
    2069. 

  2069.     ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
    2070. 

  2070.     if ( !pInfo->mpName )
    2071. 

  2071.     {
    2072. 

  2072.         // Ignore vertical fonts
    2073. 

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

  2074.         {
    2075. 

  2075.             if ( !pInfo->mbImplSalCourierNew )
    2076. 

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

  2077.             if ( !pInfo->mbImplSalCourierScalable )
    2078. 

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

  2079.             else
    2080. 

  2080.                 pInfo->mbCourier = FALSE;
    2081. 

  2081.             String aName( ImplSalGetUniString( pLogFont->elfLogFont.lfFaceName ) );
    2082. 

  2082.             pInfo->mpName = &aName;
    2083. 

  2083.             strncpy( pInfo->mpLogFontA->lfFaceName, pLogFont->elfLogFont.lfFaceName, LF_FACESIZE );
    2084. 

  2084.             pInfo->mpLogFontA->lfCharSet = pLogFont->elfLogFont.lfCharSet;
    2085. 

  2085.             EnumFontFamiliesExA( pInfo->mhDC, pInfo->mpLogFontA, (FONTENUMPROCA)SalEnumFontsProcExA,
    2086. 

  2086.                                  (LPARAM)(void*)pInfo, 0 );
    2087. 

  2087.             pInfo->mpLogFontA->lfFaceName[0] = '\0';
    2088. 

  2088.             pInfo->mpLogFontA->lfCharSet = DEFAULT_CHARSET;
    2089. 

  2089.             pInfo->mpName = NULL;
    2090. 

  2090.             pInfo->mbCourier = FALSE;
    2091. 

  2091.         }
    2092. 

  2092.     }
    2093. 

  2093.     else
    2094. 

  2094.     {
    2095. 

  2095.         // ignore non-scalable non-device font on printer
    2096. 

  2096.         if( pInfo->mbPrinter )
    2097. 

  2097.             if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
    2098. 

  2098.                 return 1;
    2099. 

  2099. 

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

  2101.         pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
    2102. 

  2102. 

  2103.         // prefer the system character set, so that we get as much as
    2104. 

  2104.         // possible important characters. In the other case we could only
    2105. 

  2105.         // display a limited set of characters (#87309#)
    2106. 

  2106.         if ( pInfo->mnPreferedCharSet == pLogFont->elfLogFont.lfCharSet )
    2107. 

  2107.             pData->mnQuality += 100;
    2108. 

  2108. 

  2109.         // knowing Courier to be scalable is nice
    2110. 

  2110.         if( pInfo->mbCourier )
    2111. 

  2111.             pInfo->mbImplSalCourierScalable |= pData->IsScalable();
    2112. 

  2112. 

  2113.         pInfo->mpList->Add( pData );
    2114. 

  2114.     }
    2115. 

  2115. 

  2116.     return 1;
    2117. 

  2117. }
    2118. 

  2118. 

  2119. // -----------------------------------------------------------------------
    2120. 

  2120. 

  2121. int CALLBACK SalEnumFontsProcExW( const ENUMLOGFONTEXW* pLogFont,
    2122. 

  2122.                                   const NEWTEXTMETRICEXW* pMetric,
    2123. 

  2123.                                   DWORD nFontType, LPARAM lParam )
    2124. 

  2124. {
    2125. 

  2125.     ImplEnumInfo* pInfo = (ImplEnumInfo*)(void*)lParam;
    2126. 

  2126.     if ( !pInfo->mpName )
    2127. 

  2127.     {
    2128. 

  2128.         // Ignore vertical fonts
    2129. 

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

  2130.         {
    2131. 

  2131.             if ( !pInfo->mbImplSalCourierNew )
    2132. 

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

  2133.             if ( !pInfo->mbImplSalCourierScalable )
    2134. 

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

  2135.             else
    2136. 

  2136.                 pInfo->mbCourier = FALSE;
    2137. 

  2137.             String aName( reinterpret_cast<const sal_Unicode*>(pLogFont->elfLogFont.lfFaceName) );
    2138. 

  2138.             pInfo->mpName = &aName;
    2139. 

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

  2140.             pInfo->mpLogFontW->lfCharSet = pLogFont->elfLogFont.lfCharSet;
    2141. 

  2141.             EnumFontFamiliesExW( pInfo->mhDC, pInfo->mpLogFontW, (FONTENUMPROCW)SalEnumFontsProcExW,
    2142. 

  2142.                                  (LPARAM)(void*)pInfo, 0 );
    2143. 

  2143.             pInfo->mpLogFontW->lfFaceName[0] = '\0';
    2144. 

  2144.             pInfo->mpLogFontW->lfCharSet = DEFAULT_CHARSET;
    2145. 

  2145.             pInfo->mpName = NULL;
    2146. 

  2146.             pInfo->mbCourier = FALSE;
    2147. 

  2147.         }
    2148. 

  2148.     }
    2149. 

  2149.     else
    2150. 

  2150.     {
    2151. 

  2151.         // ignore non-scalable non-device font on printer
    2152. 

  2152.         if( pInfo->mbPrinter )
    2153. 

  2153.             if( (nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE) )
    2154. 

  2154.                 return 1;
    2155. 

  2155. 

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

  2157.         pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
    2158. 

  2158. 

  2159.         // knowing Courier to be scalable is nice
    2160. 

  2160.         if( pInfo->mbCourier )
    2161. 

  2161.             pInfo->mbImplSalCourierScalable |= pData->IsScalable();
    2162. 

  2162. 

  2163.         pInfo->mpList->Add( pData );
    2164. 

  2164.     }
    2165. 

  2165. 

  2166.     return 1;
    2167. 

  2167. }
    2168. 

  2168. 

  2169. // -----------------------------------------------------------------------
    2170. 

  2170. 

  2171. struct TempFontItem
    2172. 

  2172. {
    2173. 

  2173.     ::rtl::OUString maFontFilePath;
    2174. 

  2174.     ::rtl::OString maResourcePath;
    2175. 

  2175.     TempFontItem* mpNextItem;
    2176. 

  2176. };
    2177. 

  2177. 

  2178. #ifdef FR_PRIVATE
    2179. 

  2179. static int WINAPI __AddFontResourceExW( LPCWSTR lpszfileName, DWORD fl, PVOID pdv )
    2180. 

  2180. {
    2181. 

  2181. 	typedef int (WINAPI *AddFontResourceExW_FUNC)(LPCWSTR, DWORD, PVOID );
    2182. 

  2182. 

  2183. 	static AddFontResourceExW_FUNC	pFunc = NULL;
    2184. 

  2184. 	static HMODULE					hmGDI = NULL;
    2185. 

  2185. 

  2186. 	if ( !pFunc && !hmGDI )
    2187. 

  2187. 	{
    2188. 

  2188. 		hmGDI = GetModuleHandleA( "GDI32" );
    2189. 

  2189. 		if ( hmGDI )
    2190. 

  2190. 			pFunc = reinterpret_cast<AddFontResourceExW_FUNC>( GetProcAddress( hmGDI, "AddFontResourceExW" ) );
    2191. 

  2191. 	}
    2192. 

  2192. 

  2193. 	if ( pFunc )
    2194. 

  2194. 		return pFunc( lpszfileName, fl, pdv );
    2195. 

  2195. 	else
    2196. 

  2196. 	{
    2197. 

  2197. 		SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    2198. 

  2198. 		return 0;
    2199. 

  2199. 	}
    2200. 

  2200. }
    2201. 

  2201. #endif
    2202. 

  2202. 

  2203. bool ImplAddTempFont( SalData& rSalData, const String& rFontFileURL )
    2204. 

  2204. {
    2205. 

  2205.     int nRet = 0;
    2206. 

  2206.     ::rtl::OUString aUSytemPath;
    2207. 

  2207.     OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
    2208. 

  2208. 

  2209. #ifdef FR_PRIVATE
    2210. 

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

  2211. #endif
    2212. 

  2212.     
    2213. 

  2213. 	if ( !nRet )
    2214. 

  2214.     {
    2215. 

  2215.         static int nCounter = 0;
    2216. 

  2216.         char aFileName[] = "soAA.fot";
    2217. 

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

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

  2219.         char aResourceName[512];
    2220. 

  2220.         int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
    2221. 

  2221.         int nLen = ::GetTempPathA( nMaxLen, aResourceName );
    2222. 

  2222.         ::strncpy( aResourceName + nLen, aFileName, sizeof( aResourceName )- nLen );
    2223. 

  2223.         // security: end buffer in any case
    2224. 

  2224.         aResourceName[ (sizeof(aResourceName)/sizeof(*aResourceName))-1 ] = 0;
    2225. 

  2225.         ::DeleteFileA( aResourceName );
    2226. 

  2226. 

  2227.         rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
    2228. 

  2228.         ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
    2229. 

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

  2230.         if( !::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL ) )
    2231. 

  2231.             return false;
    2232. 

  2232.         ++nCounter;
    2233. 

  2233. 

  2234.         nRet = ::AddFontResourceA( aResourceName );
    2235. 

  2235.         if( nRet > 0 )
    2236. 

  2236.         {
    2237. 

  2237.             TempFontItem* pNewItem = new TempFontItem;
    2238. 

  2238.             pNewItem->maResourcePath = rtl::OString( aResourceName );
    2239. 

  2239.             pNewItem->maFontFilePath = aUSytemPath.getStr();
    2240. 

  2240.             pNewItem->mpNextItem = rSalData.mpTempFontItem;
    2241. 

  2241.             rSalData.mpTempFontItem = pNewItem;
    2242. 

  2242.         }
    2243. 

  2243.     }
    2244. 

  2244. 

  2245. 	return (nRet > 0);
    2246. 

  2246. }
    2247. 

  2247. 

  2248. // -----------------------------------------------------------------------
    2249. 

  2249. 

  2250. void ImplReleaseTempFonts( SalData& rSalData )
    2251. 

  2251. {
    2252. 

  2252.     int nCount = 0;
    2253. 

  2253.     while( TempFontItem* p = rSalData.mpTempFontItem )
    2254. 

  2254.     {
    2255. 

  2255.         ++nCount;
    2256. 

  2256.         if( p->maResourcePath.getLength() )
    2257. 

  2257.         {
    2258. 

  2258.             const char* pResourcePath = p->maResourcePath.getStr();
    2259. 

  2259.             ::RemoveFontResourceA( pResourcePath );
    2260. 

  2260.             ::DeleteFileA( pResourcePath );
    2261. 

  2261.         }
    2262. 

  2262.         else
    2263. 

  2263.         {
    2264. 

  2264.             if( aSalShlData.mbWNT )
    2265. 

  2265.                 ::RemoveFontResourceW( reinterpret_cast<LPCWSTR>(p->maFontFilePath.getStr()) );
    2266. 

  2266.             else
    2267. 

  2267.             {
    2268. 

  2268.                 // poor man's string conversion because converter is gone
    2269. 

  2269.                 int nLen = p->maFontFilePath.getLength();
    2270. 

  2270.                 char* pNameA = new char[ nLen + 1 ];
    2271. 

  2271.                 for( int i = 0; i < nLen; ++i )
    2272. 

  2272.                     pNameA[i] = (char)(p->maFontFilePath.getStr())[i];
    2273. 

  2273.                 pNameA[ nLen ] = 0;
    2274. 

  2274.                 ::RemoveFontResourceA( pNameA );
    2275. 

  2275.                 delete[] pNameA;
    2276. 

  2276.             }
    2277. 

  2277.         }
    2278. 

  2278. 

  2279.         rSalData.mpTempFontItem = p->mpNextItem;
    2280. 

  2280.         delete p;
    2281. 

  2281.     }
    2282. 

  2282. 

  2283. #ifndef FR_PRIVATE
    2284. 

  2284.     // notify every other application
    2285. 

  2285.     // unless the temp fonts were installed as private fonts
    2286. 

  2286.     if( nCount > 0 )
    2287. 

  2287.         ::PostMessage( HWND_BROADCAST, WM_FONTCHANGE, 0, NULL );
    2288. 

  2288. #endif // FR_PRIVATE
    2289. 

  2289. }
    2290. 

  2290. 

  2291. // -----------------------------------------------------------------------
    2292. 

  2292. 

  2293. static bool ImplGetFontAttrFromFile( const String& rFontFileURL,
    2294. 

  2294.     ImplDevFontAttributes& rDFA )
    2295. 

  2295. {
    2296. 

  2296.     ::rtl::OUString aUSytemPath;
    2297. 

  2297.     OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFontFileURL, aUSytemPath ) );
    2298. 

  2298. 

  2299.     // get FontAttributes from a *fot file
    2300. 

  2300.     // TODO: use GetTTGlobalFontInfo() to access the font directly 
    2301. 

  2301.     rDFA.mnQuality    = 1000;
    2302. 

  2302.     rDFA.mbDevice     = true;
    2303. 

  2303.     rDFA.meFamily     = FAMILY_DONTKNOW;
    2304. 

  2304.     rDFA.meWidthType  = WIDTH_DONTKNOW;
    2305. 

  2305.     rDFA.meWeight     = WEIGHT_DONTKNOW;
    2306. 

  2306.     rDFA.meItalic     = ITALIC_DONTKNOW;
    2307. 

  2307.     rDFA.mePitch      = PITCH_DONTKNOW;;
    2308. 

  2308.     rDFA.mbSubsettable= true;
    2309. 

  2309.     rDFA.mbEmbeddable = false;
    2310. 

  2310. 

  2311.     // Create temporary file name
    2312. 

  2312.     char aFileName[] = "soAAT.fot";
    2313. 

  2313.     char aResourceName[512];
    2314. 

  2314.     int nMaxLen = sizeof(aResourceName)/sizeof(*aResourceName) - 16;
    2315. 

  2315.     int nLen = ::GetTempPathA( nMaxLen, aResourceName );
    2316. 

  2316.     ::strncpy( aResourceName + nLen, aFileName, Max( 0, nMaxLen - nLen ));
    2317. 

  2317.     ::DeleteFileA( aResourceName );
    2318. 

  2318. 

  2319.     // Create font resource file (typically with a .fot file name extension).
    2320. 

  2320.     rtl_TextEncoding theEncoding = osl_getThreadTextEncoding();
    2321. 

  2321.     ::rtl::OString aCFileName = rtl::OUStringToOString( aUSytemPath, theEncoding );
    2322. 

  2322.     ::CreateScalableFontResourceA( 0, aResourceName, aCFileName.getStr(), NULL );
    2323. 

  2323. 

  2324.     // Open and read the font resource file
    2325. 

  2325.     rtl::OUString aFotFileName = rtl::OStringToOUString( aResourceName, osl_getThreadTextEncoding() );
    2326. 

  2326.     osl::FileBase::getFileURLFromSystemPath( aFotFileName, aFotFileName );
    2327. 

  2327.     osl::File aFotFile( aFotFileName );
    2328. 

  2328.     osl::FileBase::RC aError = aFotFile.open( osl_File_OpenFlag_Read );
    2329. 

  2329.     if( aError != osl::FileBase::E_None )
    2330. 

  2330.         return false;
    2331. 

  2331. 

  2332.     sal_uInt64  nBytesRead = 0;
    2333. 

  2333.     char        aBuffer[4096];
    2334. 

  2334.     aFotFile.read( aBuffer, sizeof( aBuffer ), nBytesRead );
    2335. 

  2335.     // clean up temporary resource file
    2336. 

  2336.     aFotFile.close();
    2337. 

  2337.     ::DeleteFileA( aResourceName );
    2338. 

  2338. 

  2339.     // retrieve font family name from byte offset 0x4F6
    2340. 

  2340.     int i = 0x4F6;
    2341. 

  2341.     int nNameOfs = i;
    2342. 

  2342.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2343. 

  2343.     // skip full name
    2344. 

  2344.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2345. 

  2345.     // retrieve font style name
    2346. 

  2346.     int nStyleOfs = i;
    2347. 

  2347.     while( (i < nBytesRead) && (aBuffer[i++] != 0) );
    2348. 

  2348.     if( i >= nBytesRead )
    2349. 

  2349.         return false;
    2350. 

  2350. 

  2351.     // convert byte strings to unicode
    2352. 

  2352.     rDFA.maName      = String( aBuffer + nNameOfs, osl_getThreadTextEncoding() );
    2353. 

  2353.     rDFA.maStyleName = String( aBuffer + nStyleOfs, osl_getThreadTextEncoding() );
    2354. 

  2354. 

  2355.     // byte offset 0x4C7: OS2_fsSelection
    2356. 

  2356.     const char nFSS = aBuffer[ 0x4C7 ];
    2357. 

  2357.     if( nFSS & 0x01 )   // italic
    2358. 

  2358.         rDFA.meItalic = ITALIC_NORMAL;
    2359. 

  2359.     //if( nFSS & 0x20 )   // bold
    2360. 

  2360.     //   rDFA.meWeight = WEIGHT_BOLD;
    2361. 

  2361.     if( nFSS & 0x40 )   // regular
    2362. 

  2362.     {
    2363. 

  2363.         rDFA.meWeight = WEIGHT_NORMAL;
    2364. 

  2364.         rDFA.meItalic = ITALIC_NONE;
    2365. 

  2365.     }
    2366. 

  2366. 

  2367.     // byte offsets 0x4D7/0x4D8: wingdi's FW_WEIGHT
    2368. 

  2368.     int nWinWeight = (aBuffer[0x4D7] & 0xFF) + ((aBuffer[0x4D8] & 0xFF) << 8);
    2369. 

  2369.     rDFA.meWeight = ImplWeightToSal( nWinWeight );
    2370. 

  2370. 

  2371.     rDFA.mbSymbolFlag = false;          // TODO
    2372. 

  2372.     rDFA.mePitch      = PITCH_DONTKNOW; // TODO
    2373. 

  2373. 

  2374.     // byte offset 0x4DE: pitch&family
    2375. 

  2375.     rDFA.meFamily = ImplFamilyToSal( aBuffer[0x4DE] );
    2376. 

  2376. 

  2377.     // byte offsets 0x4C8/0x4C9: emunits
    2378. 

  2378.     // byte offsets 0x4CE/0x4CF: winascent
    2379. 

  2379.     // byte offsets 0x4D0/0x4D1: winascent+windescent-emunits
    2380. 

  2380.     // byte offsets 0x4DF/0x4E0: avgwidth
    2381. 

  2381.     //...
    2382. 

  2382. 

  2383.     return true;
    2384. 

  2384. }
    2385. 

  2385. 

  2386. // -----------------------------------------------------------------------
    2387. 

  2387. 

  2388. bool WinSalGraphics::AddTempDevFont( ImplDevFontList* pFontList,
    2389. 

  2389.     const String& rFontFileURL, const String& rFontName )
    2390. 

  2390. {
    2391. 

  2391. 	RTL_LOGFILE_TRACE1( "WinSalGraphics::AddTempDevFont(): %s", rtl::OUStringToOString( rFontFileURL, RTL_TEXTENCODING_UTF8 ).getStr() );
    2392. 

  2392. 

  2393.     ImplDevFontAttributes aDFA;
    2394. 

  2394.     aDFA.maName = rFontName;
    2395. 

  2395.     aDFA.mnQuality    = 1000;
    2396. 

  2396.     aDFA.mbDevice     = true;
    2397. 

  2397. 

  2398.     // Search Font Name in Cache
    2399. 

  2399.     if( !rFontName.Len() && mpFontAttrCache )
    2400. 

  2400.         aDFA = mpFontAttrCache->GetFontAttr( rFontFileURL );
    2401. 

  2401. 

  2402.     // Retrieve font name from font resource
    2403. 

  2403.     if( !aDFA.maName.Len() )
    2404. 

  2404.     {
    2405. 

  2405.         ImplGetFontAttrFromFile( rFontFileURL, aDFA );
    2406. 

  2406.         if( mpFontAttrCache && aDFA.maName.Len() )
    2407. 

  2407.             mpFontAttrCache->AddFontAttr( rFontFileURL, aDFA );
    2408. 

  2408.     }
    2409. 

  2409. 

  2410.     if ( !aDFA.maName.Len() )
    2411. 

  2411.         return false;
    2412. 

  2412. 

  2413.     // remember temp font for cleanup later
    2414. 

  2414.     if( !ImplAddTempFont( *GetSalData(), rFontFileURL ) )
    2415. 

  2415.         return false;
    2416. 

  2416. 

  2417.     UINT nPreferedCharSet = DEFAULT_CHARSET;
    2418. 

  2418.     if ( !aSalShlData.mbWNT )
    2419. 

  2419.     {
    2420. 

  2420.         // for W98 guess charset preference from active codepage
    2421. 

  2421.         CHARSETINFO aCharSetInfo;
    2422. 

  2422.         DWORD nCP = GetACP();
    2423. 

  2423.         if ( TranslateCharsetInfo( (DWORD*)nCP, &aCharSetInfo, TCI_SRCCODEPAGE ) )
    2424. 

  2424.             nPreferedCharSet = aCharSetInfo.ciCharset;
    2425. 

  2425.     }
    2426. 

  2426. 

  2427.     // create matching FontData struct
    2428. 

  2428.     aDFA.mbSymbolFlag = false; // TODO: how to know it without accessing the font?
    2429. 

  2429.     aDFA.meFamily     = FAMILY_DONTKNOW;
    2430. 

  2430.     aDFA.meWidthType  = WIDTH_DONTKNOW;
    2431. 

  2431.     aDFA.meWeight     = WEIGHT_DONTKNOW;
    2432. 

  2432.     aDFA.meItalic     = ITALIC_DONTKNOW;
    2433. 

  2433.     aDFA.mePitch      = PITCH_DONTKNOW;;
    2434. 

  2434.     aDFA.mbSubsettable= true;
    2435. 

  2435.     aDFA.mbEmbeddable = false;
    2436. 

  2436. 

  2437.     /*
    2438. 

  2438.     // TODO: improve ImplDevFontAttributes using the "font resource file"
    2439. 

  2439.     aDFS.maName = // using "FONTRES:" from file
    2440. 

  2440.     if( rFontName != aDFS.maName )
    2441. 

  2441.         aDFS.maMapName = aFontName;
    2442. 

  2442.     */
    2443. 

  2443. 

  2444.     ImplWinFontData* pFontData = new ImplWinFontData( aDFA, 0,
    2445. 

  2445.         sal::static_int_cast<WIN_BYTE>(nPreferedCharSet),
    2446. 

  2446.         sal::static_int_cast<WIN_BYTE>(TMPF_VECTOR|TMPF_TRUETYPE) );
    2447. 

  2447.     pFontData->SetFontId( reinterpret_cast<sal_IntPtr>(pFontData) );
    2448. 

  2448.     pFontList->Add( pFontData );
    2449. 

  2449.     return true;
    2450. 

  2450. }
    2451. 

  2451. 

  2452. // -----------------------------------------------------------------------
    2453. 

  2453. 

  2454. void WinSalGraphics::GetDevFontList( ImplDevFontList* pFontList )
    2455. 

  2455. {
    2456. 

  2456.     // make sure all fonts are registered at least temporarily
    2457. 

  2457.     static bool bOnce = true;
    2458. 

  2458.     if( bOnce )
    2459. 

  2459.     {
    2460. 

  2460.         bOnce = false;
    2461. 

  2461. 

  2462.         // determine font path
    2463. 

  2463.         // since we are only interested in fonts that could not be
    2464. 

  2464.         // registered before because of missing administration rights
    2465. 

  2465.         // only the font path of the user installation is needed
    2466. 

  2466.         ::rtl::OUString aPath;
    2467. 

  2467.         osl_getExecutableFile( &aPath.pData );
    2468. 

  2468. 		::rtl::OUString aExecutableFile( aPath );
    2469. 

  2469.         aPath = aPath.copy( 0, aPath.lastIndexOf('/') );
    2470. 

  2470.         String aFontDirUrl = aPath.copy( 0, aPath.lastIndexOf('/') );
    2471. 

  2471.         aFontDirUrl += String( RTL_CONSTASCII_USTRINGPARAM("/Basis/share/fonts/truetype") );
    2472. 

  2472. 

  2473.         // collect fonts in font path that could not be registered
    2474. 

  2474.         osl::Directory aFontDir( aFontDirUrl );
    2475. 

  2475.         osl::FileBase::RC rcOSL = aFontDir.open();
    2476. 

  2476.         if( rcOSL == osl::FileBase::E_None )
    2477. 

  2477.         {
    2478. 

  2478.             osl::DirectoryItem aDirItem;
    2479. 

  2479.             String aEmptyString;
    2480. 

  2480. 

  2481. 			::rtl::OUString aBootStrap;
    2482. 

  2482.             rtl::Bootstrap::get( String( RTL_CONSTASCII_USTRINGPARAM( "BRAND_BASE_DIR" ) ), aBootStrap );
    2483. 

  2483. 			aBootStrap += String( RTL_CONSTASCII_USTRINGPARAM( "/program/" SAL_CONFIGFILE( "bootstrap" ) ) );
    2484. 

  2484. 			rtl::Bootstrap aBootstrap( aBootStrap );
    2485. 

  2485. 			::rtl::OUString aUserPath;
    2486. 

  2486. 			aBootstrap.getFrom( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UserInstallation" ) ), aUserPath );
    2487. 

  2487. 			aUserPath += String( RTL_CONSTASCII_USTRINGPARAM("/user/config/fontnames.dat") );
    2488. 

  2488. 			String aBaseURL = aPath.copy( 0, aPath.lastIndexOf('/')+1 );
    2489. 

  2489. 			mpFontAttrCache = new ImplFontAttrCache( aUserPath, aBaseURL );
    2490. 

  2490. 

  2491. 			while( aFontDir.getNextItem( aDirItem, 10 ) == osl::FileBase::E_None )
    2492. 

  2492.             {
    2493. 

  2493.                 osl::FileStatus aFileStatus( FileStatusMask_FileURL );
    2494. 

  2494.                 rcOSL = aDirItem.getFileStatus( aFileStatus );
    2495. 

  2495.                 if ( rcOSL == osl::FileBase::E_None )
    2496. 

  2496.                     AddTempDevFont( pFontList, aFileStatus.getFileURL(), aEmptyString );
    2497. 

  2497.             }
    2498. 

  2498. 

  2499.             delete mpFontAttrCache; // destructor rewrites the cache file if needed
    2500. 

  2500.             mpFontAttrCache = NULL;
    2501. 

  2501.         }
    2502. 

  2502.     }
    2503. 

  2503. 

  2504.     ImplEnumInfo aInfo;
    2505. 

  2505.     aInfo.mhDC          = mhDC;
    2506. 

  2506.     aInfo.mpList        = pFontList;
    2507. 

  2507.     aInfo.mpName        = NULL;
    2508. 

  2508.     aInfo.mpLogFontA    = NULL;
    2509. 

  2509.     aInfo.mpLogFontW    = NULL;
    2510. 

  2510.     aInfo.mbCourier     = false;
    2511. 

  2511.     aInfo.mbPrinter     = mbPrinter;
    2512. 

  2512.     aInfo.mnFontCount   = 0;
    2513. 

  2513.     if ( !mbPrinter )
    2514. 

  2514.     {
    2515. 

  2515.         aInfo.mbImplSalCourierScalable  = false;
    2516. 

  2516.         aInfo.mbImplSalCourierNew       = false;
    2517. 

  2517.     }
    2518. 

  2518.     else
    2519. 

  2519.     {
    2520. 

  2520.         aInfo.mbImplSalCourierScalable  = true;
    2521. 

  2521.         aInfo.mbImplSalCourierNew       = true;
    2522. 

  2522.     }
    2523. 

  2523. 

  2524.     aInfo.mnPreferedCharSet = DEFAULT_CHARSET;
    2525. 

  2525.     DWORD nCP = GetACP();
    2526. 

  2526.     CHARSETINFO aCharSetInfo;
    2527. 

  2527.     if ( TranslateCharsetInfo( (DWORD*)nCP, &aCharSetInfo, TCI_SRCCODEPAGE ) )
    2528. 

  2528.         aInfo.mnPreferedCharSet = aCharSetInfo.ciCharset;
    2529. 

  2529. 

  2530.     if ( aSalShlData.mbWNT )
    2531. 

  2531.     {
    2532. 

  2532.         LOGFONTW aLogFont;
    2533. 

  2533.         memset( &aLogFont, 0, sizeof( aLogFont ) );
    2534. 

  2534.         aLogFont.lfCharSet = DEFAULT_CHARSET;
    2535. 

  2535.         aInfo.mpLogFontW = &aLogFont;
    2536. 

  2536.         EnumFontFamiliesExW( mhDC, &aLogFont,
    2537. 

  2537.             (FONTENUMPROCW)SalEnumFontsProcExW, (LPARAM)(void*)&aInfo, 0 );
    2538. 

  2538.     }
    2539. 

  2539.     else
    2540. 

  2540.     {
    2541. 

  2541.         LOGFONTA aLogFont;
    2542. 

  2542.         memset( &aLogFont, 0, sizeof( aLogFont ) );
    2543. 

  2543.         aLogFont.lfCharSet = DEFAULT_CHARSET;
    2544. 

  2544.         aInfo.mpLogFontA = &aLogFont;
    2545. 

  2545.         EnumFontFamiliesExA( mhDC, &aLogFont,
    2546. 

  2546.             (FONTENUMPROCA)SalEnumFontsProcExA, (LPARAM)(void*)&aInfo, 0 );
    2547. 

  2547.     }
    2548. 

  2548. 

  2549.     // Feststellen, was es fuer Courier-Schriften auf dem Bildschirm gibt,
    2550. 

  2550.     // um in SetFont() evt. Courier auf Courier New zu mappen
    2551. 

  2551.     if ( !mbPrinter )
    2552. 

  2552.     {
    2553. 

  2553.         bImplSalCourierScalable = aInfo.mbImplSalCourierScalable;
    2554. 

  2554.         bImplSalCourierNew      = aInfo.mbImplSalCourierNew;
    2555. 

  2555.     }
    2556. 

  2556. 

  2557. 	// set glyph fallback hook
    2558. 

  2558. 	static WinGlyphFallbackSubstititution aSubstFallback( mhDC );
    2559. 

  2559. 	pFontList->SetFallbackHook( &aSubstFallback );
    2560. 

  2560. }
    2561. 

  2561. 

  2562. // ----------------------------------------------------------------------------
    2563. 

  2563. 

  2564. void WinSalGraphics::GetDevFontSubstList( OutputDevice* )
    2565. 

  2565. {}
    2566. 

  2566. 

  2567. // -----------------------------------------------------------------------
    2568. 

  2568. 

  2569. BOOL WinSalGraphics::GetGlyphBoundRect( long nIndex, Rectangle& rRect )
    2570. 

  2570. {
    2571. 

  2571.     HDC hDC = mhDC;
    2572. 

  2572. 

  2573.     // use unity matrix
    2574. 

  2574.     MAT2 aMat;
    2575. 

  2575.     aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    2576. 

  2576.     aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
    2577. 

  2577. 

  2578.     UINT nGGOFlags = GGO_METRICS;
    2579. 

  2579.     if( !(nIndex & GF_ISCHAR) )
    2580. 

  2580.         nGGOFlags |= GGO_GLYPH_INDEX;
    2581. 

  2581.     nIndex &= GF_IDXMASK;
    2582. 

  2582. 

  2583.     GLYPHMETRICS aGM;
    2584. 

  2584.     aGM.gmptGlyphOrigin.x = aGM.gmptGlyphOrigin.y = 0;
    2585. 

  2585.     aGM.gmBlackBoxX = aGM.gmBlackBoxY = 0;
    2586. 

  2586.     DWORD nSize = GDI_ERROR;
    2587. 

  2587.     if ( aSalShlData.mbWNT )
    2588. 

  2588.         nSize = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGM, 0, NULL, &aMat );
    2589. 

  2589.     else if( (nGGOFlags & GGO_GLYPH_INDEX) || (nIndex <= 255) )
    2590. 

  2590.         nSize = ::GetGlyphOutlineA( hDC, nIndex, nGGOFlags, &aGM, 0, NULL, &aMat );
    2591. 

  2591. 

  2592.     if( nSize == GDI_ERROR )
    2593. 

  2593.         return false;
    2594. 

  2594. 

  2595.     rRect = Rectangle( Point( +aGM.gmptGlyphOrigin.x, -aGM.gmptGlyphOrigin.y ),
    2596. 

  2596.         Size( aGM.gmBlackBoxX, aGM.gmBlackBoxY ) );
    2597. 

  2597.     rRect.Left()    = static_cast<int>( mfFontScale * rRect.Left() );
    2598. 

  2598.     rRect.Right()   = static_cast<int>( mfFontScale * rRect.Right() );
    2599. 

  2599.     rRect.Top()     = static_cast<int>( mfFontScale * rRect.Top() );
    2600. 

  2600.     rRect.Bottom()  = static_cast<int>( mfFontScale * rRect.Bottom() );
    2601. 

  2601.     return true;
    2602. 

  2602. }
    2603. 

  2603. 

  2604. // -----------------------------------------------------------------------
    2605. 

  2605. 

  2606. BOOL WinSalGraphics::GetGlyphOutline( long nIndex,
    2607. 

  2607.     ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
    2608. 

  2608. {
    2609. 

  2609.     rB2DPolyPoly.clear();
    2610. 

  2610. 

  2611.     BOOL bRet = FALSE;
    2612. 

  2612.     HDC  hDC = mhDC;
    2613. 

  2613. 

  2614.     // use unity matrix
    2615. 

  2615.     MAT2 aMat;
    2616. 

  2616.     aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    2617. 

  2617.     aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
    2618. 

  2618. 

  2619.     UINT nGGOFlags = GGO_NATIVE;
    2620. 

  2620.     if( !(nIndex & GF_ISCHAR) )
    2621. 

  2621.         nGGOFlags |= GGO_GLYPH_INDEX;
    2622. 

  2622.     nIndex &= GF_IDXMASK;
    2623. 

  2623. 

  2624.     GLYPHMETRICS aGlyphMetrics;
    2625. 

  2625.     DWORD nSize1 = GDI_ERROR;
    2626. 

  2626.     if ( aSalShlData.mbWNT )
    2627. 

  2627.         nSize1 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags, &aGlyphMetrics, 0, NULL, &aMat );
    2628. 

  2628.     else if( (nGGOFlags & GGO_GLYPH_INDEX) || (nIndex <= 255) )
    2629. 

  2629.         nSize1 = ::GetGlyphOutlineA( hDC, nIndex, nGGOFlags, &aGlyphMetrics, 0, NULL, &aMat );
    2630. 

  2630. 

  2631.     if( !nSize1 )       // blank glyphs are ok
    2632. 

  2632.         bRet = TRUE;
    2633. 

  2633.     else if( nSize1 != GDI_ERROR )
    2634. 

  2634.     {
    2635. 

  2635.         BYTE*   pData = new BYTE[ nSize1 ];
    2636. 

  2636.         DWORD   nSize2;
    2637. 

  2637.         if ( aSalShlData.mbWNT )
    2638. 

  2638.             nSize2 = ::GetGlyphOutlineW( hDC, nIndex, nGGOFlags,
    2639. 

  2639.                 &aGlyphMetrics, nSize1, pData, &aMat );
    2640. 

  2640.         else
    2641. 

  2641.             nSize2 = ::GetGlyphOutlineA( hDC, nIndex, nGGOFlags,
    2642. 

  2642.                 &aGlyphMetrics, nSize1, pData, &aMat );
    2643. 

  2643. 

  2644.         if( nSize1 == nSize2 )
    2645. 

  2645.         {
    2646. 

  2646.             bRet = TRUE;
    2647. 

  2647. 

  2648.             int     nPtSize = 512;
    2649. 

  2649.             Point*  pPoints = new Point[ nPtSize ];
    2650. 

  2650.             BYTE*   pFlags = new BYTE[ nPtSize ];
    2651. 

  2651. 

  2652.             TTPOLYGONHEADER* pHeader = (TTPOLYGONHEADER*)pData;
    2653. 

  2653.             while( (BYTE*)pHeader < pData+nSize2 )
    2654. 

  2654.             {
    2655. 

  2655.                 // only outline data is interesting
    2656. 

  2656.                 if( pHeader->dwType != TT_POLYGON_TYPE )
    2657. 

  2657.                     break;
    2658. 

  2658. 

  2659.                 // get start point; next start points are end points
    2660. 

  2660.                 // of previous segment
    2661. 

  2661.                 USHORT nPnt = 0;
    2662. 

  2662. 

  2663.                 long nX = IntTimes256FromFixed( pHeader->pfxStart.x );
    2664. 

  2664.                 long nY = IntTimes256FromFixed( pHeader->pfxStart.y );
    2665. 

  2665.                 pPoints[ nPnt ] = Point( nX, nY );
    2666. 

  2666.                 pFlags[ nPnt++ ] = POLY_NORMAL;
    2667. 

  2667. 

  2668.                 bool bHasOfflinePoints = false;
    2669. 

  2669.                 TTPOLYCURVE* pCurve = (TTPOLYCURVE*)( pHeader + 1 );
    2670. 

  2670.                 pHeader = (TTPOLYGONHEADER*)( (BYTE*)pHeader + pHeader->cb );
    2671. 

  2671.                 while( (BYTE*)pCurve < (BYTE*)pHeader )
    2672. 

  2672.                 {
    2673. 

  2673.                     int nNeededSize = nPnt + 16 + 3 * pCurve->cpfx;
    2674. 

  2674.                     if( nPtSize < nNeededSize )
    2675. 

  2675.                     {
    2676. 

  2676.                         Point* pOldPoints = pPoints;
    2677. 

  2677.                         BYTE* pOldFlags = pFlags;
    2678. 

  2678.                         nPtSize = 2 * nNeededSize;
    2679. 

  2679.                         pPoints = new Point[ nPtSize ];
    2680. 

  2680.                         pFlags = new BYTE[ nPtSize ];
    2681. 

  2681.                         for( USHORT i = 0; i < nPnt; ++i )
    2682. 

  2682.                         {
    2683. 

  2683.                             pPoints[ i ] = pOldPoints[ i ];
    2684. 

  2684.                             pFlags[ i ] = pOldFlags[ i ];
    2685. 

  2685.                         }
    2686. 

  2686.                         delete[] pOldPoints;
    2687. 

  2687.                         delete[] pOldFlags;
    2688. 

  2688.                     }
    2689. 

  2689. 

  2690.                     int i = 0;
    2691. 

  2691.                     if( TT_PRIM_LINE == pCurve->wType )
    2692. 

  2692.                     {
    2693. 

  2693.                         while( i < pCurve->cpfx )
    2694. 

  2694.                         {
    2695. 

  2695.                             nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2696. 

  2696.                             nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2697. 

  2697.                             ++i;
    2698. 

  2698.                             pPoints[ nPnt ] = Point( nX, nY );
    2699. 

  2699.                             pFlags[ nPnt ] = POLY_NORMAL;
    2700. 

  2700.                             ++nPnt;
    2701. 

  2701.                         }
    2702. 

  2702.                     }
    2703. 

  2703.                     else if( TT_PRIM_QSPLINE == pCurve->wType )
    2704. 

  2704.                     {
    2705. 

  2705.                         bHasOfflinePoints = true;
    2706. 

  2706.                         while( i < pCurve->cpfx )
    2707. 

  2707.                         {
    2708. 

  2708.                             // get control point of quadratic bezier spline
    2709. 

  2709.                             nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2710. 

  2710.                             nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2711. 

  2711.                             ++i;
    2712. 

  2712.                             Point aControlP( nX, nY );
    2713. 

  2713. 

  2714.                             // calculate first cubic control point
    2715. 

  2715.                             // P0 = 1/3 * (PBeg + 2 * PQControl)
    2716. 

  2716.                             nX = pPoints[ nPnt-1 ].X() + 2 * aControlP.X();
    2717. 

  2717.                             nY = pPoints[ nPnt-1 ].Y() + 2 * aControlP.Y();
    2718. 

  2718.                             pPoints[ nPnt+0 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
    2719. 

  2719.                             pFlags[ nPnt+0 ] = POLY_CONTROL;
    2720. 

  2720. 

  2721.                             // calculate endpoint of segment
    2722. 

  2722.                             nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
    2723. 

  2723.                             nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
    2724. 

  2724. 

  2725.                             if ( i+1 >= pCurve->cpfx )
    2726. 

  2726.                             {
    2727. 

  2727.                                 // endpoint is either last point in segment => advance
    2728. 

  2728.                                 ++i;
    2729. 

  2729.                             }
    2730. 

  2730.                             else
    2731. 

  2731.                             {
    2732. 

  2732.                                 // or endpoint is the middle of two control points
    2733. 

  2733.                                 nX += IntTimes256FromFixed( pCurve->apfx[ i-1 ].x );
    2734. 

  2734.                                 nY += IntTimes256FromFixed( pCurve->apfx[ i-1 ].y );
    2735. 

  2735.                                 nX = (nX + 1) / 2;
    2736. 

  2736.                                 nY = (nY + 1) / 2;
    2737. 

  2737.                                 // no need to advance, because the current point
    2738. 

  2738.                                 // is the control point in next bezier spline
    2739. 

  2739.                             }
    2740. 

  2740. 

  2741.                             pPoints[ nPnt+2 ] = Point( nX, nY );
    2742. 

  2742.                             pFlags[ nPnt+2 ] = POLY_NORMAL;
    2743. 

  2743. 

  2744.                             // calculate second cubic control point
    2745. 

  2745.                             // P1 = 1/3 * (PEnd + 2 * PQControl)
    2746. 

  2746.                             nX = pPoints[ nPnt+2 ].X() + 2 * aControlP.X();
    2747. 

  2747.                             nY = pPoints[ nPnt+2 ].Y() + 2 * aControlP.Y();
    2748. 

  2748.                             pPoints[ nPnt+1 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
    2749. 

  2749.                             pFlags[ nPnt+1 ] = POLY_CONTROL;
    2750. 

  2750. 

  2751.                             nPnt += 3;
    2752. 

  2752.                         }
    2753. 

  2753.                     }
    2754. 

  2754. 

  2755.                     // next curve segment
    2756. 

  2756.                     pCurve = (TTPOLYCURVE*)&pCurve->apfx[ i ];
    2757. 

  2757.                 }
    2758. 

  2758. 

  2759.                 // end point is start point for closed contour
    2760. 

  2760.                 // disabled, because Polygon class closes the contour itself
    2761. 

  2761.                 // pPoints[nPnt++] = pPoints[0];
    2762. 

  2762. 				// #i35928#
    2763. 

  2763. 				// Added again, but add only when not yet closed
    2764. 

  2764. 				if(pPoints[nPnt - 1] != pPoints[0])
    2765. 

  2765. 				{
    2766. 

  2766.                     if( bHasOfflinePoints )
    2767. 

  2767.                         pFlags[nPnt] = pFlags[0];
    2768. 

  2768. 

  2769. 					pPoints[nPnt++] = pPoints[0];
    2770. 

  2770. 				}
    2771. 

  2771. 

  2772.                 // convert y-coordinates W32 -> VCL
    2773. 

  2773.                 for( int i = 0; i < nPnt; ++i )
    2774. 

  2774.                     pPoints[i].Y() = -pPoints[i].Y();
    2775. 

  2775. 

  2776.                 // insert into polypolygon
    2777. 

  2777.                 Polygon aPoly( nPnt, pPoints, (bHasOfflinePoints ? pFlags : NULL) );
    2778. 

  2778.                 // convert to B2DPolyPolygon
    2779. 

  2779.                 // TODO: get rid of the intermediate PolyPolygon
    2780. 

  2780.                 rB2DPolyPoly.append( aPoly.getB2DPolygon() );
    2781. 

  2781.             }
    2782. 

  2782. 

  2783.             delete[] pPoints;
    2784. 

  2784.             delete[] pFlags;
    2785. 

  2785.         }
    2786. 

  2786. 

  2787.         delete[] pData;
    2788. 

  2788.     }
    2789. 

  2789. 

  2790.     // rescaling needed for the PolyPolygon conversion
    2791. 

  2791.     if( rB2DPolyPoly.count() )
    2792. 

  2792.     {
    2793. 

  2793. 		const double fFactor(mfFontScale/256);
    2794. 

  2794. 		rB2DPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix(fFactor, fFactor));
    2795. 

  2795.     }
    2796. 

  2796. 

  2797.     return bRet;
    2798. 

  2798. }
    2799. 

  2799. 

  2800. // -----------------------------------------------------------------------
    2801. 

  2801. 

  2802. class ScopedFont
    2803. 

  2803. {
    2804. 

  2804. public:
    2805. 

  2805.     explicit ScopedFont(WinSalGraphics & rData);
    2806. 

  2806. 

  2807.     ~ScopedFont();
    2808. 

  2808. 

  2809. private:
    2810. 

  2810.     WinSalGraphics & m_rData;
    2811. 

  2811.     HFONT m_hOrigFont;
    2812. 

  2812. };
    2813. 

  2813. 

  2814. ScopedFont::ScopedFont(WinSalGraphics & rData): m_rData(rData)
    2815. 

  2815. {
    2816. 

  2816.     m_hOrigFont = m_rData.mhFonts[0];
    2817. 

  2817.     m_rData.mhFonts[0] = 0; // avoid deletion of current font
    2818. 

  2818. }
    2819. 

  2819. 

  2820. ScopedFont::~ScopedFont()
    2821. 

  2821. {
    2822. 

  2822.     if( m_hOrigFont )
    2823. 

  2823.     {
    2824. 

  2824.         // restore original font, destroy temporary font
    2825. 

  2825.         HFONT hTempFont = m_rData.mhFonts[0];
    2826. 

  2826.         m_rData.mhFonts[0] = m_hOrigFont;
    2827. 

  2827.         SelectObject( m_rData.mhDC, m_hOrigFont );
    2828. 

  2828.         DeleteObject( hTempFont );
    2829. 

  2829.     }
    2830. 

  2830. }
    2831. 

  2831. 

  2832. class ScopedTrueTypeFont
    2833. 

  2833. {
    2834. 

  2834. public:
    2835. 

  2835.     inline ScopedTrueTypeFont(): m_pFont(0) {}
    2836. 

  2836. 

  2837.     ~ScopedTrueTypeFont();
    2838. 

  2838. 

  2839.     int open(void * pBuffer, sal_uInt32 nLen, sal_uInt32 nFaceNum);
    2840. 

  2840. 

  2841.     inline TrueTypeFont * get() const { return m_pFont; }
    2842. 

  2842. 

  2843. private:
    2844. 

  2844.     TrueTypeFont * m_pFont;
    2845. 

  2845. };
    2846. 

  2846. 

  2847. ScopedTrueTypeFont::~ScopedTrueTypeFont()
    2848. 

  2848. {
    2849. 

  2849.     if (m_pFont != 0)
    2850. 

  2850.         CloseTTFont(m_pFont);
    2851. 

  2851. }
    2852. 

  2852. 

  2853. int ScopedTrueTypeFont::open(void * pBuffer, sal_uInt32 nLen,
    2854. 

  2854.                              sal_uInt32 nFaceNum)
    2855. 

  2855. {
    2856. 

  2856.     OSL_ENSURE(m_pFont == 0, "already open");
    2857. 

  2857.     return OpenTTFontBuffer(pBuffer, nLen, nFaceNum, &m_pFont);
    2858. 

  2858. }
    2859. 

  2859. 

  2860. BOOL WinSalGraphics::CreateFontSubset( const rtl::OUString& rToFile,
    2861. 

  2861.     const ImplFontData* pFont, long* pGlyphIDs, sal_uInt8* pEncoding,
    2862. 

  2862.     sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
    2863. 

  2863. {
    2864. 

  2864.     // TODO: use more of the central font-subsetting code, move stuff there if needed
    2865. 

  2865. 

  2866.     // create matching ImplFontSelectData
    2867. 

  2867.     // we need just enough to get to the font file data
    2868. 

  2868.     // use height=1000 for easier debugging (to match psprint's font units)
    2869. 

  2869.     ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    2870. 

  2870. 

  2871.     // TODO: much better solution: move SetFont and restoration of old font to caller
    2872. 

  2872.     ScopedFont aOldFont(*this);
    2873. 

  2873.     float fScale = 1.0;
    2874. 

  2874.     HFONT hOldFont = 0;
    2875. 

  2875.     ImplDoSetFont( &aIFSD, fScale, hOldFont );
    2876. 

  2876. 

  2877.     ImplWinFontData* pWinFontData = (ImplWinFontData*)aIFSD.mpFontData;
    2878. 

  2878.     pWinFontData->UpdateFromHDC( mhDC );
    2879. 

  2879. /*const*/ ImplFontCharMap* pImplFontCharMap = pWinFontData->GetImplFontCharMap();
    2880. 

  2880. 

  2881. #if OSL_DEBUG_LEVEL > 1
    2882. 

  2882.     // get font metrics
    2883. 

  2883.     TEXTMETRICA aWinMetric;
    2884. 

  2884.     if( !::GetTextMetricsA( mhDC, &aWinMetric ) )
    2885. 

  2885.         return FALSE;
    2886. 

  2886. 

  2887.     DBG_ASSERT( !(aWinMetric.tmPitchAndFamily & TMPF_DEVICE), "cannot subset device font" );
    2888. 

  2888.     DBG_ASSERT( aWinMetric.tmPitchAndFamily & TMPF_TRUETYPE, "can only subset TT font" );
    2889. 

  2889. #endif
    2890. 

  2890. 

  2891.     rtl::OUString aSysPath;
    2892. 

  2892.     if( osl_File_E_None != osl_getSystemPathFromFileURL( rToFile.pData, &aSysPath.pData ) )
    2893. 

  2893.         return FALSE;
    2894. 

  2894.     const rtl_TextEncoding aThreadEncoding = osl_getThreadTextEncoding();
    2895. 

  2895.     const ByteString aToFile( aSysPath.getStr(), (xub_StrLen)aSysPath.getLength(), aThreadEncoding );
    2896. 

  2896. 

  2897. 	// check if the font has a CFF-table
    2898. 

  2898. 	const DWORD nCffTag = CalcTag( "CFF " );
    2899. 

  2899. 	const RawFontData aRawCffData( mhDC, nCffTag );
    2900. 

  2900. 	if( aRawCffData.get() )
    2901. 

  2901. 	{
    2902. 

  2902. 		long nRealGlyphIds[ 256 ];
    2903. 

  2903. 		for( int i = 0; i < nGlyphCount; ++i )
    2904. 

  2904. 		{
    2905. 

  2905. 			// TODO: remap notdef glyph if needed
    2906. 

  2906. 			// TODO: use GDI's GetGlyphIndices instead? Does it handle GSUB properly?
    2907. 

  2907. 			sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
    2908. 

  2908. 			if( pGlyphIDs[i] & GF_ISCHAR ) // remaining pseudo-glyphs need to be translated
    2909. 

  2909. 				nGlyphIdx = pImplFontCharMap->GetGlyphIndex( nGlyphIdx );
    2910. 

  2910. 			if( (pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0)	// TODO: vertical substitution
    2911. 

  2911. 				{/*####*/}
    2912. 

  2912. 

  2913. 			nRealGlyphIds[i] = nGlyphIdx;
    2914. 

  2914. 		}
    2915. 

  2915. 

  2916. 		// provide a font subset from the CFF-table
    2917. 

  2917. 		FILE* pOutFile = fopen( aToFile.GetBuffer(), "wb" );
    2918. 

  2918. 		rInfo.LoadFont( FontSubsetInfo::CFF_FONT, aRawCffData.get(), aRawCffData.size() );
    2919. 

  2919. 		bool bRC = rInfo.CreateFontSubset( FontSubsetInfo::TYPE1_PFB, pOutFile, NULL,
    2920. 

  2920. 				nRealGlyphIds, pEncoding, nGlyphCount, pGlyphWidths );
    2921. 

  2921. 		fclose( pOutFile );
    2922. 

  2922. 		return bRC;
    2923. 

  2923. 	}
    2924. 

  2924. 

  2925.     // get raw font file data
    2926. 

  2926.     const RawFontData xRawFontData( mhDC, NULL );
    2927. 

  2927.     if( !xRawFontData.get() )
    2928. 

  2928. 		return FALSE;
    2929. 

  2929. 

  2930.     // open font file
    2931. 

  2931.     sal_uInt32 nFaceNum = 0;
    2932. 

  2932.     if( !*xRawFontData.get() )  // TTC candidate
    2933. 

  2933.         nFaceNum = ~0U;  // indicate "TTC font extracts only"
    2934. 

  2934. 

  2935.     ScopedTrueTypeFont aSftTTF;
    2936. 

  2936.     int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
    2937. 

  2937.     if( nRC != SF_OK )
    2938. 

  2938.         return FALSE;
    2939. 

  2939. 

  2940.     TTGlobalFontInfo aTTInfo;
    2941. 

  2941.     ::GetTTGlobalFontInfo( aSftTTF.get(), &aTTInfo );
    2942. 

  2942.     rInfo.m_nFontType   = FontSubsetInfo::SFNT_TTF;
    2943. 

  2943.     rInfo.m_aPSName     = ImplSalGetUniString( aTTInfo.psname );
    2944. 

  2944.     rInfo.m_nAscent	    = +aTTInfo.winAscent;
    2945. 

  2945.     rInfo.m_nDescent    = -aTTInfo.winDescent;
    2946. 

  2946.     rInfo.m_aFontBBox	= Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
    2947. 

  2947.                                     Point( aTTInfo.xMax, aTTInfo.yMax ) );
    2948. 

  2948.     rInfo.m_nCapHeight	= aTTInfo.yMax; // Well ...
    2949. 

  2949. 

  2950.     // subset TTF-glyphs and get their properties
    2951. 

  2951.     // take care that subset fonts require the NotDef glyph in pos 0
    2952. 

  2952.     int nOrigCount = nGlyphCount;
    2953. 

  2953.     USHORT    aShortIDs[ 256 ];
    2954. 

  2954.     sal_uInt8 aTempEncs[ 256 ];
    2955. 

  2955. 

  2956.     int nNotDef=-1, i;
    2957. 

  2957.     for( i = 0; i < nGlyphCount; ++i )
    2958. 

  2958.     {
    2959. 

  2959.         aTempEncs[i] = pEncoding[i];
    2960. 

  2960.         sal_uInt32 nGlyphIdx = pGlyphIDs[i] & GF_IDXMASK;
    2961. 

  2961.         if( pGlyphIDs[i] & GF_ISCHAR )
    2962. 

  2962.         {
    2963. 

  2963.         	sal_Unicode cChar = static_cast<sal_Unicode>(nGlyphIdx); // TODO: sal_UCS4
    2964. 

  2964.         	const bool bVertical = ((pGlyphIDs[i] & (GF_ROTMASK|GF_GSUB)) != 0);
    2965. 

  2965.             nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
    2966. 

  2966.             if( (nGlyphIdx == 0) && pFont->IsSymbolFont() )
    2967. 

  2967.             {
    2968. 

  2968.                 // #i12824# emulate symbol aliasing U+FXXX <-> U+0XXX
    2969. 

  2969.                 cChar = (cChar & 0xF000) ? (cChar & 0x00FF) : (cChar | 0xF000);
    2970. 

  2970.                 nGlyphIdx = ::MapChar( aSftTTF.get(), cChar, bVertical );
    2971. 

  2971.             }
    2972. 

  2972.         }
    2973. 

  2973.         aShortIDs[i] = static_cast<USHORT>( nGlyphIdx );
    2974. 

  2974.         if( !nGlyphIdx )
    2975. 

  2975.             if( nNotDef < 0 )
    2976. 

  2976.                 nNotDef = i; // first NotDef glyph found
    2977. 

  2977.     }
    2978. 

  2978. 

  2979.     if( nNotDef != 0 )
    2980. 

  2980.     {
    2981. 

  2981.         // add fake NotDef glyph if needed
    2982. 

  2982.         if( nNotDef < 0 )
    2983. 

  2983.             nNotDef = nGlyphCount++;
    2984. 

  2984. 

  2985.         // NotDef glyph must be in pos 0 => swap glyphids
    2986. 

  2986.         aShortIDs[ nNotDef ] = aShortIDs[0];
    2987. 

  2987.         aTempEncs[ nNotDef ] = aTempEncs[0];
    2988. 

  2988.         aShortIDs[0] = 0;
    2989. 

  2989.         aTempEncs[0] = 0;
    2990. 

  2990.     }
    2991. 

  2991.     DBG_ASSERT( nGlyphCount < 257, "too many glyphs for subsetting" );
    2992. 

  2992. 

  2993.     // fill pWidth array
    2994. 

  2994.     TTSimpleGlyphMetrics* pMetrics =
    2995. 

  2995.         ::GetTTSimpleGlyphMetrics( aSftTTF.get(), aShortIDs, nGlyphCount, aIFSD.mbVertical );
    2996. 

  2996.     if( !pMetrics )
    2997. 

  2997.         return FALSE;
    2998. 

  2998.     sal_uInt16 nNotDefAdv   = pMetrics[0].adv;
    2999. 

  2999.     pMetrics[0].adv         = pMetrics[nNotDef].adv;
    3000. 

  3000.     pMetrics[nNotDef].adv   = nNotDefAdv;
    3001. 

  3001.     for( i = 0; i < nOrigCount; ++i )
    3002. 

  3002.         pGlyphWidths[i] = pMetrics[i].adv;
    3003. 

  3003.     free( pMetrics );
    3004. 

  3004. 

  3005.     // write subset into destination file
    3006. 

  3006.     nRC = ::CreateTTFromTTGlyphs( aSftTTF.get(), aToFile.GetBuffer(), aShortIDs,
    3007. 

  3007.             aTempEncs, nGlyphCount, 0, NULL, 0 );
    3008. 

  3008.     return (nRC == SF_OK);
    3009. 

  3009. }
    3010. 

  3010. 

  3011. //--------------------------------------------------------------------------
    3012. 

  3012. 

  3013. const void* WinSalGraphics::GetEmbedFontData( const ImplFontData* pFont,
    3014. 

  3014.     const sal_Unicode* pUnicodes, sal_Int32* pCharWidths,
    3015. 

  3015.     FontSubsetInfo& rInfo, long* pDataLen )
    3016. 

  3016. {
    3017. 

  3017.     // create matching ImplFontSelectData
    3018. 

  3018.     // we need just enough to get to the font file data
    3019. 

  3019.     ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    3020. 

  3020. 

  3021.     // TODO: much better solution: move SetFont and restoration of old font to caller
    3022. 

  3022.     ScopedFont aOldFont(*this);
    3023. 

  3023.     SetFont( &aIFSD, 0 );
    3024. 

  3024. 

  3025.     // get the raw font file data
    3026. 

  3026.     RawFontData aRawFontData( mhDC );
    3027. 

  3027.     *pDataLen = aRawFontData.size();
    3028. 

  3028.     if( !aRawFontData.get() )
    3029. 

  3029.         return NULL;
    3030. 

  3030. 

  3031.     // get important font properties
    3032. 

  3032.     TEXTMETRICA aTm;
    3033. 

  3033.     if( !::GetTextMetricsA( mhDC, &aTm ) )
    3034. 

  3034.         *pDataLen = 0;
    3035. 

  3035.     const bool bPFA = (*aRawFontData.get() < 0x80);
    3036. 

  3036.     rInfo.m_nFontType = bPFA ? FontSubsetInfo::TYPE1_PFA : FontSubsetInfo::TYPE1_PFB;
    3037. 

  3037.     WCHAR aFaceName[64];
    3038. 

  3038.     int nFNLen = ::GetTextFaceW( mhDC, 64, aFaceName );
    3039. 

  3039.     // #i59854# strip eventual null byte
    3040. 

  3040.     while( nFNLen > 0 && aFaceName[nFNLen-1] == 0 )
    3041. 

  3041.         nFNLen--;
    3042. 

  3042.     if( nFNLen == 0 )
    3043. 

  3043.         *pDataLen = 0;
    3044. 

  3044.     rInfo.m_aPSName     = String( reinterpret_cast<const sal_Unicode*>(aFaceName), sal::static_int_cast<USHORT>(nFNLen) );
    3045. 

  3045.     rInfo.m_nAscent     = +aTm.tmAscent;
    3046. 

  3046.     rInfo.m_nDescent    = -aTm.tmDescent;
    3047. 

  3047.     rInfo.m_aFontBBox   = Rectangle( Point( -aTm.tmOverhang, -aTm.tmDescent ),
    3048. 

  3048.               Point( aTm.tmMaxCharWidth, aTm.tmAscent+aTm.tmExternalLeading ) );
    3049. 

  3049.     rInfo.m_nCapHeight  = aTm.tmAscent; // Well ...
    3050. 

  3050. 

  3051.     // get individual character widths
    3052. 

  3052.     for( int i = 0; i < 256; ++i )
    3053. 

  3053.     {
    3054. 

  3054.         int nCharWidth = 0;
    3055. 

  3055.         const sal_Unicode cChar = pUnicodes[i];
    3056. 

  3056.         if( !::GetCharWidth32W( mhDC, cChar, cChar, &nCharWidth ) )
    3057. 

  3057.             *pDataLen = 0;
    3058. 

  3058.         pCharWidths[i] = nCharWidth;
    3059. 

  3059.     }
    3060. 

  3060.     
    3061. 

  3061.     if( !*pDataLen )
    3062. 

  3062.         return NULL;
    3063. 

  3063. 

  3064. 	const unsigned char* pData = aRawFontData.steal();
    3065. 

  3065.     return (void*)pData;
    3066. 

  3066. }
    3067. 

  3067. 

  3068. //--------------------------------------------------------------------------
    3069. 

  3069. 

  3070. void WinSalGraphics::FreeEmbedFontData( const void* pData, long /*nLen*/ )
    3071. 

  3071. {
    3072. 

  3072.     delete[] reinterpret_cast<char*>(const_cast<void*>(pData));
    3073. 

  3073. }
    3074. 

  3074. 

  3075. //--------------------------------------------------------------------------
    3076. 

  3076. 

  3077. const Ucs2SIntMap* WinSalGraphics::GetFontEncodingVector( const ImplFontData* pFont, const Ucs2OStrMap** pNonEncoded )
    3078. 

  3078. {
    3079. 

  3079.     // TODO: even for builtin fonts we get here... why?
    3080. 

  3080.     if( !pFont->IsEmbeddable() )
    3081. 

  3081.         return NULL;
    3082. 

  3082. 

  3083.     // fill the encoding vector
    3084. 

  3084.     // currently no nonencoded vector
    3085. 

  3085.     if( pNonEncoded )
    3086. 

  3086.         *pNonEncoded = NULL;
    3087. 

  3087. 

  3088.     const ImplWinFontData* pWinFontData = static_cast<const ImplWinFontData*>(pFont);
    3089. 

  3089.     const Ucs2SIntMap* pEncoding = pWinFontData->GetEncodingVector();
    3090. 

  3090.     if( pEncoding == NULL )
    3091. 

  3091.     {
    3092. 

  3092.         Ucs2SIntMap* pNewEncoding = new Ucs2SIntMap;
    3093. 

  3093.         #if 0
    3094. 

  3094.         // TODO: get correct encoding vector
    3095. 

  3095.         GLYPHSET aGlyphSet;
    3096. 

  3096.         aGlyphSet.cbThis = sizeof(aGlyphSet);
    3097. 

  3097.         DWORD aW = ::GetFontUnicodeRanges( mhDC, &aGlyphSet);
    3098. 

  3098.         #else
    3099. 

  3099.         for( sal_Unicode i = 32; i < 256; ++i )
    3100. 

  3100.             (*pNewEncoding)[i] = i;
    3101. 

  3101.         #endif
    3102. 

  3102.         pWinFontData->SetEncodingVector( pNewEncoding );
    3103. 

  3103. 	pEncoding = pNewEncoding;
    3104. 

  3104.     }
    3105. 

  3105. 

  3106.     return pEncoding;
    3107. 

  3107. }
    3108. 

  3108. 

  3109. //--------------------------------------------------------------------------
    3110. 

  3110. 

  3111. void WinSalGraphics::GetGlyphWidths( const ImplFontData* pFont,
    3112. 

  3112.                                      bool bVertical,
    3113. 

  3113.                                      Int32Vector& rWidths,
    3114. 

  3114.                                      Ucs2UIntMap& rUnicodeEnc )
    3115. 

  3115. {
    3116. 

  3116.     // create matching ImplFontSelectData
    3117. 

  3117.     // we need just enough to get to the font file data
    3118. 

  3118.     ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );
    3119. 

  3119. 

  3120.     // TODO: much better solution: move SetFont and restoration of old font to caller
    3121. 

  3121.     ScopedFont aOldFont(*this);
    3122. 

  3122.     
    3123. 

  3123.     float fScale = 0.0;
    3124. 

  3124.     HFONT hOldFont = 0;
    3125. 

  3125.     ImplDoSetFont( &aIFSD, fScale, hOldFont );
    3126. 

  3126.     
    3127. 

  3127.     if( pFont->IsSubsettable() )
    3128. 

  3128.     {
    3129. 

  3129.         // get raw font file data
    3130. 

  3130.         const RawFontData xRawFontData( mhDC );
    3131. 

  3131. 	    if( !xRawFontData.get() )
    3132. 

  3132. 			return;
    3133. 

  3133. 

  3134.         // open font file
    3135. 

  3135.         sal_uInt32 nFaceNum = 0;
    3136. 

  3136.         if( !*xRawFontData.get() )  // TTC candidate
    3137. 

  3137.             nFaceNum = ~0U;  // indicate "TTC font extracts only"
    3138. 

  3138.     
    3139. 

  3139.         ScopedTrueTypeFont aSftTTF;
    3140. 

  3140.         int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
    3141. 

  3141.         if( nRC != SF_OK )
    3142. 

  3142.             return;
    3143. 

  3143.     
    3144. 

  3144.         int nGlyphs = GetTTGlyphCount( aSftTTF.get() );
    3145. 

  3145.         if( nGlyphs > 0 )
    3146. 

  3146.         {
    3147. 

  3147.             rWidths.resize(nGlyphs);
    3148. 

  3148.             std::vector<sal_uInt16> aGlyphIds(nGlyphs);
    3149. 

  3149.             for( int i = 0; i < nGlyphs; i++ )
    3150. 

  3150.                 aGlyphIds[i] = sal_uInt16(i);
    3151. 

  3151.             TTSimpleGlyphMetrics* pMetrics = ::GetTTSimpleGlyphMetrics( aSftTTF.get(),
    3152. 

  3152.                                                                         &aGlyphIds[0],
    3153. 

  3153.                                                                         nGlyphs,
    3154. 

  3154.                                                                         bVertical ? 1 : 0 );
    3155. 

  3155.             if( pMetrics )
    3156. 

  3156.             {
    3157. 

  3157.                 for( int i = 0; i< nGlyphs; i++ )
    3158. 

  3158.                     rWidths[i] = pMetrics[i].adv;
    3159. 

  3159.                 free( pMetrics );
    3160. 

  3160.                 rUnicodeEnc.clear();
    3161. 

  3161.             }
    3162. 

  3162.             const ImplWinFontData* pWinFont = static_cast<const ImplWinFontData*>(pFont);
    3163. 

  3163.             ImplFontCharMap* pMap = pWinFont->GetImplFontCharMap();
    3164. 

  3164. 			DBG_ASSERT( pMap && pMap->GetCharCount(), "no map" );
    3165. 

  3165. 

  3166. 			int nCharCount = pMap->GetCharCount();
    3167. 

  3167.             sal_uInt32 nChar = pMap->GetFirstChar();
    3168. 

  3168. 			for( int i = 0; i < nCharCount; i++ )
    3169. 

  3169.             {
    3170. 

  3170.                 if( nChar < 0x00010000 )
    3171. 

  3171.                 {
    3172. 

  3172.                     sal_uInt16 nGlyph = ::MapChar( aSftTTF.get(),
    3173. 

  3173.                                                    static_cast<sal_Ucs>(nChar),
    3174. 

  3174.                                                    bVertical ? 1 : 0 );
    3175. 

  3175.                     if( nGlyph )
    3176. 

  3176.                         rUnicodeEnc[ static_cast<sal_Unicode>(nChar) ] = nGlyph;
    3177. 

  3177.                 }
    3178. 

  3178. 				nChar = pMap->GetNextChar( nChar );
    3179. 

  3179.             }
    3180. 

  3180.         }
    3181. 

  3181.     }
    3182. 

  3182.     else if( pFont->IsEmbeddable() )
    3183. 

  3183.     {
    3184. 

  3184.         // get individual character widths
    3185. 

  3185.         rWidths.clear();
    3186. 

  3186.         rUnicodeEnc.clear();
    3187. 

  3187.         rWidths.reserve( 224 );
    3188. 

  3188.         for( sal_Unicode i = 32; i < 256; ++i )
    3189. 

  3189.         {
    3190. 

  3190.             int nCharWidth = 0;
    3191. 

  3191.             if( ::GetCharWidth32W( mhDC, i, i, &nCharWidth ) )
    3192. 

  3192.             {
    3193. 

  3193.                 rUnicodeEnc[ i ] = rWidths.size();
    3194. 

  3194.                 rWidths.push_back( nCharWidth );
    3195. 

  3195.             }
    3196. 

  3196.         }
    3197. 

  3197.     }    
    3198. 

  3198. }
    3199. 

  3199. 

  3200. //--------------------------------------------------------------------------
    3201. 

  3201. 

  3202. void WinSalGraphics::DrawServerFontLayout( const ServerFontLayout& )
    3203. 

  3203. {}
    3204. 

  3204. 

  3205. //--------------------------------------------------------------------------
    3206. 

  3206. 

  3207. SystemFontData WinSalGraphics::GetSysFontData( int nFallbacklevel ) const
    3208. 

  3208. {
    3209. 

  3209.     SystemFontData aSysFontData;
    3210. 

  3210. 

  3211.     if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
    3212. 

  3212.     if (nFallbacklevel < 0 ) nFallbacklevel = 0;
    3213. 

  3213.     
    3214. 

  3214.     aSysFontData.nSize = sizeof( SystemFontData );
    3215. 

  3215.     aSysFontData.hFont = mhFonts[nFallbacklevel]; 
    3216. 

  3216.     aSysFontData.bFakeBold = false;
    3217. 

  3217.     aSysFontData.bFakeItalic = false;
    3218. 

  3218.     aSysFontData.bAntialias = true;
    3219. 

  3219.     aSysFontData.bVerticalCharacterType = false;
    3220. 

  3220.     
    3221. 

  3221.     OSL_TRACE("\r\n:WinSalGraphics::GetSysFontData(): FontID: %p, Fallback level: %d",
    3222. 

  3222.               aSysFontData.hFont,
    3223. 

  3223.               nFallbacklevel);
    3224. 

  3224. 

  3225.     return aSysFontData;
    3226. 

  3226. }
    3227. 

  3227. 

  3228. //--------------------------------------------------------------------------
    3229. 

  3229. 

  3230.