1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef _PSPRINT_FONTMANAGER_HXX_ 25 #define _PSPRINT_FONTMANAGER_HXX_ 26 27 #include <hash_map> 28 #include <map> 29 #include <list> 30 #include <set> 31 #include <vector> 32 33 #include "vcl/dllapi.h" 34 #include "vcl/helper.hxx" 35 #include "salglyphid.hxx" 36 37 #include "com/sun/star/lang/Locale.hpp" 38 39 #define ATOM_FAMILYNAME 2 40 #define ATOM_PSNAME 3 41 42 /* 43 * some words on metrics: every length returned by PrintFontManager and 44 * friends are PostScript afm style, that is they are 1/1000 font height 45 */ 46 47 // forward declarations 48 namespace utl { class MultiAtomProvider; } // see unotools/atom.hxx 49 class FontSubsetInfo; 50 class ImplFontOptions; 51 52 namespace psp { 53 class PPDParser; // see ppdparser.hxx 54 55 namespace italic 56 { 57 enum type { 58 Upright = 0, 59 Oblique = 1, 60 Italic = 2, 61 Unknown = 3 62 }; 63 } 64 65 namespace width 66 { 67 enum type { 68 Unknown = 0, 69 UltraCondensed = 1, 70 ExtraCondensed = 2, 71 Condensed = 3, 72 SemiCondensed = 4, 73 Normal = 5, 74 SemiExpanded = 6, 75 Expanded = 7, 76 ExtraExpanded = 8, 77 UltraExpanded = 9 78 }; 79 } 80 81 namespace pitch 82 { 83 enum type { 84 Unknown = 0, 85 Fixed = 1, 86 Variable = 2 87 }; 88 } 89 90 namespace weight 91 { 92 enum type { 93 Unknown = 0, 94 Thin = 1, 95 UltraLight = 2, 96 Light = 3, 97 SemiLight = 4, 98 Normal = 5, 99 Medium = 6, 100 SemiBold = 7, 101 Bold = 8, 102 UltraBold = 9, 103 Black = 10 104 }; 105 } 106 107 namespace family 108 { 109 enum type { 110 Unknown = 0, 111 Decorative = 1, 112 Modern = 2, 113 Roman = 3, 114 Script = 4, 115 Swiss = 5, 116 System = 6 117 }; 118 } 119 120 namespace fonttype 121 { 122 enum type { 123 Unknown = 0, 124 Type1 = 1, 125 TrueType = 2, 126 Builtin = 3 127 }; 128 } 129 130 namespace fcstatus 131 { 132 enum type { 133 istrue, 134 isunset, 135 isfalse 136 }; 137 } 138 139 /* 140 * the difference between FastPrintFontInfo and PrintFontInfo 141 * is that the information in FastPrintFontInfo can usually 142 * be gathered without openening either the font file or 143 * an afm metric file. they are gathered from fonts.dir alone. 144 * if only FastPrintFontInfo is gathered and PrintFontInfo 145 * on demand and for less fonts, then performance in startup 146 * increases considerably 147 */ 148 149 struct FastPrintFontInfo 150 { 151 fontID m_nID; // FontID 152 fonttype::type m_eType; 153 154 // font attributes 155 rtl::OUString m_aFamilyName; 156 rtl::OUString m_aStyleName; 157 std::list< rtl::OUString > m_aAliases; 158 family::type m_eFamilyStyle; 159 italic::type m_eItalic; 160 width::type m_eWidth; 161 weight::type m_eWeight; 162 pitch::type m_ePitch; 163 rtl_TextEncoding m_aEncoding; 164 bool m_bSubsettable; 165 bool m_bEmbeddable; 166 FastPrintFontInfopsp::FastPrintFontInfo167 FastPrintFontInfo() : 168 m_nID( 0 ), 169 m_eType( fonttype::Unknown ), 170 m_eFamilyStyle( family::Unknown ), 171 m_eItalic( italic::Unknown ), 172 m_eWidth( width::Unknown ), 173 m_eWeight( weight::Unknown ), 174 m_ePitch( pitch::Unknown ), 175 m_aEncoding( RTL_TEXTENCODING_DONTKNOW ) 176 {} 177 }; 178 179 struct PrintFontInfo : public FastPrintFontInfo 180 { 181 int m_nAscend; 182 int m_nDescend; 183 int m_nLeading; 184 int m_nWidth; 185 PrintFontInfopsp::PrintFontInfo186 PrintFontInfo() : 187 FastPrintFontInfo(), 188 m_nAscend( 0 ), 189 m_nDescend( 0 ), 190 m_nLeading( 0 ), 191 m_nWidth( 0 ) 192 {} 193 }; 194 195 // the values are per thousand of the font size 196 // note: width, height contain advances, not bounding box 197 struct CharacterMetric 198 { 199 short int width, height; 200 CharacterMetricpsp::CharacterMetric201 CharacterMetric() : width( 0 ), height( 0 ) {} operator ==psp::CharacterMetric202 bool operator==( const CharacterMetric& rOther ) const 203 { return rOther.width == width && rOther.height == height; } operator !=psp::CharacterMetric204 bool operator!=( const CharacterMetric& rOther ) const 205 { return rOther.width != width || rOther.height != height; } 206 }; 207 208 struct KernPair 209 { 210 sal_Unicode first, second; 211 short int kern_x, kern_y; 212 KernPairpsp::KernPair213 KernPair() : first( 0 ), second( 0 ), kern_x( 0 ), kern_y( 0 ) {} 214 }; 215 216 class FontCache; 217 218 // a class to manage printable fonts 219 // aims are type1 and truetype fonts 220 221 class FontCache; 222 223 class VCL_PLUGIN_PUBLIC PrintFontManager 224 { 225 struct PrintFont; 226 struct TrueTypeFontFile; 227 struct Type1FontFile; 228 struct BuiltinFont; 229 friend struct PrintFont; 230 friend struct TrueTypeFontFile; 231 friend struct Type1FontFile; 232 friend struct BuiltinFont; 233 friend class FontCache; 234 235 struct PrintFontMetrics 236 { 237 // character metrics are stored by the following keys: 238 // lower two bytes contain a sal_Unicode (a UCS2 character) 239 // upper byte contains: 0 for horizontal metric 240 // 1 for vertical metric 241 // highest byte: 0 for now 242 std::hash_map< int, CharacterMetric > m_aMetrics; 243 // contains the unicode blocks for which metrics were queried 244 // this implies that metrics should be queried in terms of 245 // unicode blocks. here a unicode block is identified 246 // by the upper byte of the UCS2 encoding. 247 // note that the corresponding bit should be set even 248 // if the font does not support a single character of that page 249 // this map shows, which pages were queried already 250 // if (like in AFM metrics) all metrics are queried in 251 // a single pass, then all bits should be set 252 char m_aPages[32]; 253 254 bool m_bKernPairsQueried; 255 std::list< KernPair > m_aXKernPairs; 256 std::list< KernPair > m_aYKernPairs; 257 std::hash_map< sal_Unicode, bool > m_bVerticalSubstitutions; 258 PrintFontMetricspsp::PrintFontManager::PrintFontMetrics259 PrintFontMetrics() : m_bKernPairsQueried( false ) {} 260 isEmptypsp::PrintFontManager::PrintFontMetrics261 bool isEmpty() const { return m_aMetrics.empty(); } 262 }; 263 264 struct PrintFont 265 { 266 fonttype::type m_eType; 267 268 // font attributes 269 int m_nFamilyName; // atom 270 std::list< int > m_aAliases; 271 int m_nPSName; // atom 272 rtl::OUString m_aStyleName; 273 italic::type m_eItalic; 274 width::type m_eWidth; 275 weight::type m_eWeight; 276 pitch::type m_ePitch; 277 rtl_TextEncoding m_aEncoding; 278 bool m_bFontEncodingOnly; // set if font should be only accessed by builtin encoding 279 CharacterMetric m_aGlobalMetricX; 280 CharacterMetric m_aGlobalMetricY; 281 PrintFontMetrics* m_pMetrics; 282 int m_nAscend; 283 int m_nDescend; 284 int m_nLeading; 285 int m_nXMin; // font bounding box 286 int m_nYMin; 287 int m_nXMax; 288 int m_nYMax; 289 bool m_bHaveVerticalSubstitutedGlyphs; 290 bool m_bUserOverride; 291 292 std::map< sal_Unicode, sal_Int32 > m_aEncodingVector; 293 std::map< sal_Unicode, rtl::OString > m_aNonEncoded; 294 295 explicit PrintFont( fonttype::type eType ); 296 virtual ~PrintFont(); 297 virtual bool queryMetricPage( int nPage, utl::MultiAtomProvider* pProvider ) = 0; 298 299 bool readAfmMetrics( const rtl::OString& rFileName, utl::MultiAtomProvider* pProvider, bool bFillEncodingvector, bool bOnlyGlobalAttributes ); 300 }; 301 302 struct Type1FontFile : public PrintFont 303 { 304 int m_nDirectory; // atom containing system dependent path 305 rtl::OString m_aFontFile; // relative to directory 306 rtl::OString m_aMetricFile; // dito 307 rtl::OString m_aXLFD; // mainly for administration, contains the XLFD from fonts.dir 308 309 /* note: m_aFontFile and Metric file are not atoms 310 because they should be fairly unique */ 311 Type1FontFilepsp::PrintFontManager::Type1FontFile312 Type1FontFile() : PrintFont( fonttype::Type1 ), m_nDirectory( 0 ) {} 313 virtual ~Type1FontFile(); 314 virtual bool queryMetricPage( int nPage, utl::MultiAtomProvider* pProvider ); 315 }; 316 317 struct TrueTypeFontFile : public PrintFont 318 { 319 int m_nDirectory; // atom containing system dependent path 320 rtl::OString m_aFontFile; // relative to directory 321 rtl::OString m_aXLFD; // mainly for administration, contains the XLFD from fonts.dir 322 int m_nCollectionEntry; // -1 for regular fonts, 0 to ... for fonts stemming from collections 323 unsigned int m_nTypeFlags; // copyright bits and PS-OpenType flag 324 325 TrueTypeFontFile(); 326 virtual ~TrueTypeFontFile(); 327 virtual bool queryMetricPage( int nPage, utl::MultiAtomProvider* pProvider ); 328 }; 329 330 struct BuiltinFont : public PrintFont 331 { 332 int m_nDirectory; // atom containing system dependent path 333 rtl::OString m_aMetricFile; 334 BuiltinFontpsp::PrintFontManager::BuiltinFont335 BuiltinFont() : PrintFont( fonttype::Builtin ) {} 336 virtual ~BuiltinFont(); 337 virtual bool queryMetricPage( int nPage, utl::MultiAtomProvider* pProvider ); 338 }; 339 340 struct XLFDEntry 341 { 342 static const int MaskFoundry = 1; 343 static const int MaskFamily = 2; 344 static const int MaskAddStyle = 4; 345 static const int MaskItalic = 8; 346 static const int MaskWeight = 16; 347 static const int MaskWidth = 32; 348 static const int MaskPitch = 64; 349 static const int MaskEncoding = 128; 350 351 int nMask; // contains a bit set for every valid member 352 353 rtl::OString aFoundry; 354 rtl::OString aFamily; 355 rtl::OString aAddStyle; 356 italic::type eItalic; 357 weight::type eWeight; 358 width::type eWidth; 359 pitch::type ePitch; 360 rtl_TextEncoding aEncoding; 361 XLFDEntrypsp::PrintFontManager::XLFDEntry362 XLFDEntry() { nMask = 0; } 363 364 bool operator<(const XLFDEntry& rRight) const; 365 bool operator==(const XLFDEntry& rRight) const; 366 }; 367 368 static rtl::OString s_aEmptyOString; 369 370 fontID m_nNextFontID; 371 std::hash_map< fontID, PrintFont* > m_aFonts; 372 std::hash_map< int, family::type > m_aFamilyTypes; 373 std::list< rtl::OUString > m_aPrinterDrivers; 374 std::list< rtl::OString > m_aFontDirectories; 375 std::list< int > m_aPrivateFontDirectories; 376 std::map< struct XLFDEntry, std::list< struct XLFDEntry > > 377 m_aXLFD_Aliases; 378 utl::MultiAtomProvider* m_pAtoms; 379 // for speeding up findFontFileID 380 std::hash_map< rtl::OString, std::set< fontID >, rtl::OStringHash > 381 m_aFontFileToFontID; 382 383 std::hash_map< rtl::OString, int, rtl::OStringHash > 384 m_aDirToAtom; 385 std::hash_map< int, rtl::OString > m_aAtomToDir; 386 int m_nNextDirAtom; 387 388 std::hash_multimap< rtl::OString, sal_Unicode, rtl::OStringHash > 389 m_aAdobenameToUnicode; 390 std::hash_multimap< sal_Unicode, rtl::OString > 391 m_aUnicodeToAdobename; 392 std::hash_multimap< sal_Unicode, sal_uInt8 > m_aUnicodeToAdobecode; 393 std::hash_multimap< sal_uInt8, sal_Unicode > m_aAdobecodeToUnicode; 394 395 mutable FontCache* m_pFontCache; 396 bool m_bFontconfigSuccess; 397 398 mutable std::vector< fontID > m_aOverrideFonts; 399 400 rtl::OString getAfmFile( PrintFont* pFont ) const; 401 rtl::OString getFontFile( PrintFont* pFont ) const; 402 403 void getFontAttributesFromXLFD( PrintFont* pFont, const std::list< rtl::OString >& rXLFDs ) const; 404 405 bool analyzeFontFile( int nDirID, const rtl::OString& rFileName, const std::list< rtl::OString >& rXLFDs, std::list< PrintFont* >& rNewFonts ) const; 406 rtl::OUString convertTrueTypeName( void* pNameRecord ) const; // actually a NameRecord* formt font subsetting code 407 void analyzeTrueTypeFamilyName( void* pTTFont, std::list< rtl::OUString >& rnames ) const; // actually a TrueTypeFont* from font subsetting code 408 bool analyzeTrueTypeFile( PrintFont* pFont ) const; 409 // finds the FIRST id for this font file; there may be more 410 // for TrueType collections 411 fontID findFontFileID( int nDirID, const rtl::OString& rFile ) const; 412 fontID findFontBuiltinID( int nPSNameAtom ) const; 413 414 family::type matchFamilyName( const rtl::OUString& rFamily ) const; 415 getFont(fontID nID) const416 PrintFont* getFont( fontID nID ) const 417 { 418 std::hash_map< fontID, PrintFont* >::const_iterator it; 419 it = m_aFonts.find( nID ); 420 return it == m_aFonts.end() ? NULL : it->second; 421 } 422 rtl::OString getXLFD( PrintFont* pFont ) const; 423 void fillPrintFontInfo( PrintFont* pFont, FastPrintFontInfo& rInfo ) const; 424 void fillPrintFontInfo( PrintFont* pFont, PrintFontInfo& rInfo ) const; 425 426 const rtl::OString& getDirectory( int nAtom ) const; 427 int getDirectoryAtom( const rtl::OString& rDirectory, bool bCreate = false ); 428 429 /* try to initialize fonts from libfontconfig 430 431 called from <code>initialize()</code> 432 433 @returns 434 true if at least one font was added by libfontconfig 435 false else (e.g. no libfontconfig found) 436 */ 437 bool initFontconfig(); 438 int countFontconfigFonts( std::hash_map<rtl::OString, int, rtl::OStringHash>& o_rVisitedPaths ); 439 /* deinitialize fontconfig 440 */ 441 void deinitFontconfig(); 442 443 /* register an application specific font directory for libfontconfig 444 445 since fontconfig is asked for font substitutes before OOo will check for font availability 446 and fontconfig will happily substitute fonts it doesn't know (e.g. "Arial Narrow" -> "DejaVu Sans Book"!) 447 it becomes necessary to tell the library about all the hidden font treasures 448 449 @returns 450 true if libfontconfig accepted the directory 451 false else (e.g. no libfontconfig found) 452 */ 453 bool addFontconfigDir(const rtl::OString& rDirectory); 454 455 static bool parseXLFD( const rtl::OString& rXLFD, XLFDEntry& rEntry ); 456 void parseXLFD_appendAliases( const std::list< rtl::OString >& rXLFDs, std::list< XLFDEntry >& rEntries ) const; 457 void initFontsAlias(); 458 459 bool readOverrideMetrics(); 460 461 PrintFontManager(); 462 ~PrintFontManager(); 463 public: 464 static PrintFontManager& get(); // one instance only 465 466 int addFontFile( const rtl::OString& rFileName, int nFaceNum ); 467 468 void initialize(); 469 470 // returns the number of managed fonts getFontCount() const471 int getFontCount() const { return m_aFonts.size(); } 472 473 // caution: the getFontList* methods can change the font list on demand 474 // depending on the pParser argument. That is getFontCount() may 475 // return a larger value after getFontList() 476 477 // returns the ids of all managed fonts. on pParser != NULL 478 // all fonttype::Builtin type fonts are not listed 479 // which do not occur in the PPD of pParser 480 void getFontList( std::list< fontID >& rFontIDs, const PPDParser* pParser = NULL, bool bUseOverrideMetrics = false ); 481 // get the font list and detailed font info. see getFontList for pParser 482 void getFontListWithInfo( std::list< PrintFontInfo >& rFonts, const PPDParser* pParser = NULL, bool bUseOverrideMetrics = false ); 483 // get the font list and fast font info. see getFontList for pParser 484 void getFontListWithFastInfo( std::list< FastPrintFontInfo >& rFonts, const PPDParser* pParser = NULL, bool bUseOverrideMetrics = false ); 485 486 // get font info for a specific font 487 bool getFontInfo( fontID nFontID, PrintFontInfo& rInfo ) const; 488 // get fast font info for a specific font 489 bool getFontFastInfo( fontID nFontID, FastPrintFontInfo& rInfo ) const; 490 491 // routines to get font info in small pieces 492 493 // get a specific fonts family name 494 const rtl::OUString& getFontFamily( fontID nFontID ) const; 495 // get a specific fonts PSName name 496 const rtl::OUString& getPSName( fontID nFontID ) const; 497 498 // get a specific fonts style family 499 family::type getFontFamilyType( fontID nFontID ) const; 500 501 // get a specific fonts family name aliases 502 void getFontFamilyAliases( fontID nFontID ) const; 503 504 // get a specific fonts type getFontType(fontID nFontID) const505 fonttype::type getFontType( fontID nFontID ) const 506 { 507 PrintFont* pFont = getFont( nFontID ); 508 return pFont ? pFont->m_eType : fonttype::Unknown; 509 } 510 511 // get a specific fonts italic type getFontItalic(fontID nFontID) const512 italic::type getFontItalic( fontID nFontID ) const 513 { 514 PrintFont* pFont = getFont( nFontID ); 515 return pFont ? pFont->m_eItalic : italic::Unknown; 516 } 517 518 // get a specific fonts width type getFontWidth(fontID nFontID) const519 width::type getFontWidth( fontID nFontID ) const 520 { 521 PrintFont* pFont = getFont( nFontID ); 522 return pFont ? pFont->m_eWidth : width::Unknown; 523 } 524 525 // get a specific fonts weight type getFontWeight(fontID nFontID) const526 weight::type getFontWeight( fontID nFontID ) const 527 { 528 PrintFont* pFont = getFont( nFontID ); 529 return pFont ? pFont->m_eWeight : weight::Unknown; 530 } 531 532 // get a specific fonts pitch type getFontPitch(fontID nFontID) const533 pitch::type getFontPitch( fontID nFontID ) const 534 { 535 PrintFont* pFont = getFont( nFontID ); 536 return pFont ? pFont->m_ePitch : pitch::Unknown; 537 } 538 539 // get a specific fonts encoding getFontEncoding(fontID nFontID) const540 rtl_TextEncoding getFontEncoding( fontID nFontID ) const 541 { 542 PrintFont* pFont = getFont( nFontID ); 543 return pFont ? pFont->m_aEncoding : RTL_TEXTENCODING_DONTKNOW; 544 } 545 546 // should i only use font's builtin encoding ? getUseOnlyFontEncoding(fontID nFontID) const547 bool getUseOnlyFontEncoding( fontID nFontID ) const 548 { 549 PrintFont* pFont = getFont( nFontID ); 550 return pFont ? pFont->m_bFontEncodingOnly : false; 551 } 552 553 // get a specific fonts system dependent filename getFontFileSysPath(fontID nFontID) const554 rtl::OString getFontFileSysPath( fontID nFontID ) const 555 { 556 return getFontFile( getFont( nFontID ) ); 557 } 558 559 // get the ttc face number 560 int getFontFaceNumber( fontID nFontID ) const; 561 562 // get a specific fonts global metrics 563 const CharacterMetric& getGlobalFontMetric( fontID nFontID, bool bHorizontal ) const; 564 565 // get a specific fonts ascend 566 int getFontAscend( fontID nFontID ) const; 567 568 // get a specific fonts descent 569 int getFontDescend( fontID nFontID ) const; 570 571 // get a specific fonts leading 572 int getFontLeading( fontID nFontID ) const; 573 574 // get a fonts glyph bounding box 575 bool getFontBoundingBox( fontID nFont, int& xMin, int& yMin, int& xMax, int& yMax ); 576 577 // info whether there are vertical substitutions 578 bool hasVerticalSubstitutions( fontID nFontID ) const; 579 580 // info whether an array of glyphs has vertical substitutions 581 void hasVerticalSubstitutions( fontID nFontID, const sal_Unicode* pCharacters, 582 int nCharacters, bool* pHasSubst ) const; 583 584 // get the XLFD for a font that originated from the X fontpath 585 // note: this may not be the original line that was in the fonts.dir 586 // returns a string for every font, but only TrueType and Type1 587 // fonts originated from the X font path, so check for the font type 588 rtl::OUString getFontXLFD( fontID nFontID ) const; 589 590 // get a specific fonts metrics 591 592 // get metrics for a sal_Unicode range 593 // the user is responsible to allocate pArray large enough 594 bool getMetrics( fontID nFontID, sal_Unicode minCharacter, sal_Unicode maxCharacter, CharacterMetric* pArray, bool bVertical = false ) const; 595 // get metrics for an array of sal_Unicode characters 596 // the user is responsible to allocate pArray large enough 597 bool getMetrics( fontID nFontID, const sal_Unicode* pString, int nLen, CharacterMetric* pArray, bool bVertical = false ) const; 598 599 // get encoding vector of font, currently only for Type1 and Builtin fonts 600 // returns NULL if encoding vector is empty or font is neither type1 or 601 // builtin; if ppNonEncoded is set and non encoded type1 glyphs exist 602 // then *ppNonEncoded is set to the mapping for nonencoded glyphs. 603 // the encoding vector contains -1 for non encoded glyphs 604 const std::map< sal_Unicode, sal_Int32 >* getEncodingMap( fontID nFontID, const std::map< sal_Unicode, rtl::OString >** ppNonEncoded ) const; 605 606 // to get font substitution transparently use the 607 // getKernPairs method of PrinterGfx 608 const std::list< KernPair >& getKernPairs( fontID nFontID, bool bVertical = false ) const; 609 610 // evaluates copyright flags for TrueType fonts 611 // type1 fonts do not have such a feature, so return for them is true 612 // returns true for builtin fonts (surprise!) 613 bool isFontDownloadingAllowed( fontID nFont ) const; 614 615 // helper for type 1 fonts 616 std::list< rtl::OString > getAdobeNameFromUnicode( sal_Unicode aChar ) const; 617 618 std::pair< std::hash_multimap< sal_Unicode, sal_uInt8 >::const_iterator, 619 std::hash_multimap< sal_Unicode, sal_uInt8 >::const_iterator > getAdobeCodeFromUnicode(sal_Unicode aChar) const620 getAdobeCodeFromUnicode( sal_Unicode aChar ) const 621 { 622 return m_aUnicodeToAdobecode.equal_range( aChar ); 623 } 624 std::list< sal_Unicode > getUnicodeFromAdobeName( const rtl::OString& rName ) const; 625 std::pair< std::hash_multimap< sal_uInt8, sal_Unicode >::const_iterator, 626 std::hash_multimap< sal_uInt8, sal_Unicode >::const_iterator > getUnicodeFromAdobeCode(sal_uInt8 aChar) const627 getUnicodeFromAdobeCode( sal_uInt8 aChar ) const 628 { 629 return m_aAdobecodeToUnicode.equal_range( aChar ); 630 } 631 632 // creates a new font subset of an existing TrueType font 633 // returns true in case of success, else false 634 // nFont: the font to be subsetted 635 // rOutFile: the file to put the new subset into; 636 // must be a valid osl file URL 637 // pGlyphIDs: input array of glyph ids for new font 638 // pNewEncoding: the corresponding encoding in the new font 639 // pWidths: output array of widths of requested glyphs 640 // nGlyphs: number of glyphs in arrays 641 // pCapHeight:: capital height of the produced font 642 // pXMin, pYMin, pXMax, pYMax: outgoing font bounding box 643 // TODO: callers of this method should use its FontSubsetInfo counterpart directly 644 bool createFontSubset( FontSubsetInfo&, 645 fontID nFont, 646 const rtl::OUString& rOutFile, 647 sal_GlyphId* pGlyphIds, 648 sal_uInt8* pNewEncoding, 649 sal_Int32* pWidths, 650 int nGlyphs, 651 bool bVertical = false 652 ); 653 void getGlyphWidths( fontID nFont, 654 bool bVertical, 655 std::vector< sal_Int32 >& rWidths, 656 std::map< sal_Unicode, sal_uInt32 >& rUnicodeEnc ); 657 658 659 // font administration functions 660 661 // for importFonts to provide the user feedback 662 class ImportFontCallback 663 { 664 public: 665 enum FailCondition { NoWritableDirectory, NoAfmMetric, AfmCopyFailed, FontCopyFailed }; 666 virtual void importFontsFailed( FailCondition eReason ) = 0; 667 virtual void progress( const rtl::OUString& rFile ) = 0; 668 virtual bool queryOverwriteFile( const rtl::OUString& rFile ) = 0; 669 virtual void importFontFailed( const rtl::OUString& rFile, FailCondition ) = 0; 670 virtual bool isCanceled() = 0; 671 }; 672 673 // checks whether font import would fail due to no writeable directory 674 bool checkImportPossible() const; 675 // expects system paths not UNC paths 676 // returns the number of fonts successfully imported 677 int importFonts( const std::list< rtl::OString >& rFiles, bool bLinkOnly = false, ImportFontCallback* pCallback = NULL ); 678 679 // check whether changeFontProperties would fail due to not writable fonts.dir 680 bool checkChangeFontPropertiesPossible( fontID nFont ) const; 681 // change fonts.dir entry for font 682 bool changeFontProperties( fontID nFont, const rtl::OUString& rXLFD ); 683 684 // get properties of a not imported font file 685 bool getImportableFontProperties( const rtl::OString& rFile, std::list< FastPrintFontInfo >& rFontProps ); 686 687 // get fonts that come from the same font file 688 bool getFileDuplicates( fontID nFont, std::list< fontID >& rFonts ) const; 689 // remove font files 690 bool removeFonts( const std::list< fontID >& rFonts ); 691 692 bool isPrivateFontFile( fontID ) const; 693 694 // returns false if there were not any 695 bool getAlternativeFamilyNames( fontID nFont, std::list< rtl::OUString >& rNames ) const; 696 697 /* system dependendent font matching 698 699 <p> 700 <code>matchFont</code> matches a pattern of font characteristics 701 and returns the closest match if possibe. If a match was found 702 the <code>FastPrintFontInfo</code> passed in as parameter 703 will be update to the found matching font. 704 </p> 705 <p> 706 implementation note: currently the function is only implemented 707 for fontconfig. 708 </p> 709 710 @param rInfo 711 out of the FastPrintFontInfo structure the following 712 fields will be used for the match: 713 <ul> 714 <li>family name</li> 715 <li>italic</li> 716 <li>width</li> 717 <li>weight</li> 718 <li>pitch</li> 719 </ul> 720 721 @param rLocale 722 if <code>rLocal</code> contains non empty strings the corresponding 723 locale will be used for font matching also; e.g. "Sans" can result 724 in different fonts in e.g. english and japanese 725 726 @returns 727 true if a match was found 728 false else 729 */ 730 bool matchFont( FastPrintFontInfo& rInfo, const com::sun::star::lang::Locale& rLocale ); 731 bool getFontOptions( const FastPrintFontInfo&, int nSize, void (*subcallback)(void*), ImplFontOptions& rResult ) const; 732 733 rtl::OUString Substitute( const rtl::OUString& rFontName, rtl::OUString& rMissingCodes, 734 const rtl::OString& rLangAttrib, italic::type& rItalic, weight::type& rWeight, 735 width::type& rWidth, pitch::type& rPitch) const; hasFontconfig() const736 bool hasFontconfig() const { return m_bFontconfigSuccess; } 737 738 int FreeTypeCharIndex( void *pFace, sal_uInt32 aChar ); 739 }; 740 741 } // namespace 742 743 #endif // _PSPRINT_FONTMANAGER_HXX_ 744