vcl/generic/fontmanager/fontcache.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <cstdlib>
  22 #include <cstring>
  23
  24 #include "fontcache.hxx"
  25
  26 #include "osl/thread.h"
  27
  28 #include "unotools/atom.hxx"
  29
  30 #include "tools/stream.hxx"
  31
  32 #include <rtl/strbuf.hxx>
  33
  34 #include <unistd.h>
  35 #include <sys/stat.h>
  36
  37 #if OSL_DEBUG_LEVEL >1
  38 #include <cstdio>
  39 #endif
  40
  41 #define FONTCACHEFILE "/user/psprint/pspfontcache"
  42 #define CACHE_MAGIC "LibreOffice PspFontCacheFile format 5"
  43
  44 using namespace std;
  45 using namespace psp;
  46 using namespace utl;
  47
  48
  49 /*
  50  *  FontCache constructor
  51  */
  52
  53 FontCache::FontCache()
  54 {
  55     m_bDoFlush = false;
  56     m_aCacheFile = getOfficePath( UserPath );
  57     if( m_aCacheFile.Len() )
  58     {
  59         m_aCacheFile.AppendAscii( FONTCACHEFILE );
  60         read();
  61     }
  62 }
  63
  64 /*
  65  *  FontCache destructor
  66  */
  67
  68 FontCache::~FontCache()
  69 {
  70     clearCache();
  71 }
  72
  73 /*
  74  *  FontCache::clearCache
  75  */
  76 void FontCache::clearCache()
  77 {
  78     for( FontCacheData::iterator dir_it = m_aCache.begin(); dir_it != m_aCache.end(); ++dir_it )
  79     {
  80         for( FontDirMap::iterator entry_it = dir_it->second.m_aEntries.begin(); entry_it != dir_it->second.m_aEntries.end(); ++entry_it )
  81         {
  82             for( FontCacheEntry::iterator font_it = entry_it->second.m_aEntry.begin(); font_it != entry_it->second.m_aEntry.end(); ++font_it )
  83                 delete *font_it;
  84         }
  85     }
  86     m_aCache.clear();
  87 }
  88
  89 /*
  90  *  FontCache::Commit
  91  */
  92
  93 void FontCache::flush()
  94 {
  95     if( ! m_bDoFlush || ! m_aCacheFile.Len() )
  96         return;
  97
  98     SvFileStream aStream;
  99     aStream.Open( m_aCacheFile, STREAM_WRITE | STREAM_TRUNC );
 100     if( ! (aStream.IsOpen() && aStream.IsWritable()) )
 101     {
 102 #if OSL_DEBUG_LEVEL > 1
 103         fprintf( stderr, "FontCache::flush: opening cache file %s failed\n", OUStringToOString(m_aCacheFile, osl_getThreadTextEncoding()).getStr() );
 104 #endif
 105         return;
 106     }
 107
 108     aStream.SetLineDelimiter( LINEEND_LF );
 109     aStream.WriteLine( CACHE_MAGIC );
 110
 111     PrintFontManager& rManager( PrintFontManager::get() );
 112     MultiAtomProvider* pAtoms = rManager.m_pAtoms;
 113
 114     for( FontCacheData::const_iterator dir_it = m_aCache.begin(); dir_it != m_aCache.end(); ++ dir_it )
 115     {
 116         const FontDirMap& rDir( dir_it->second.m_aEntries );
 117
 118         OString aDirectory(rManager.getDirectory(dir_it->first));
 119         OStringBuffer aLine("FontCacheDirectory:");
 120         aLine.append(dir_it->second.m_nTimestamp);
 121         aLine.append(':');
 122         aLine.append(aDirectory);
 123         if( rDir.empty() && dir_it->second.m_bNoFiles )
 124             aLine.insert(0, "Empty");
 125         aStream.WriteLine(aLine.makeStringAndClear());
 126
 127         for( FontDirMap::const_iterator entry_it = rDir.begin(); entry_it != rDir.end(); ++entry_it )
 128         {
 129             // insert cache entries
 130             const FontCacheEntry& rEntry( entry_it->second.m_aEntry );
 131             if( rEntry.begin() == rEntry.end() )
 132                 continue;
 133
 134             aLine.append("File:");
 135             aLine.append(entry_it->first);
 136             aStream.WriteLine(aLine.makeStringAndClear());
 137
 138             int nEntrySize = entry_it->second.m_aEntry.size();
 139             // write: type;nfonts
 140             aLine.append(static_cast<sal_Int32>(rEntry.front()->m_eType));
 141             aLine.append(';');
 142             aLine.append(static_cast<sal_Int32>(nEntrySize));
 143             aStream.WriteLine(aLine.makeStringAndClear());
 144
 145             sal_Int32 nSubEntry = 0;
 146             for( FontCacheEntry::const_iterator it = rEntry.begin(); it != rEntry.end(); ++it, nSubEntry++ )
 147             {
 148                 /*
 149                  *  for each font entry write:
 150                  *  name[;name[;name]]
 151                  *  fontnr;PSName;italic;weight;width;pitch;encoding;ascend;descend;leading;vsubst;gxw;gxh;gyw;gyh;useroverrride;embed;antialias[;{metricfile,typeflags}][;stylename]
 152                  */
 153                 if( nEntrySize > 1 )
 154                     nSubEntry = static_cast<const PrintFontManager::TrueTypeFontFile*>(*it)->m_nCollectionEntry;
 155                 else
 156                     nSubEntry = 0;
 157
 158                 aLine.append(OUStringToOString(pAtoms->getString( ATOM_FAMILYNAME, (*it)->m_nFamilyName), RTL_TEXTENCODING_UTF8));
 159                 for( ::std::list< int >::const_iterator name_it = (*it)->m_aAliases.begin(); name_it != (*it)->m_aAliases.end(); ++name_it )
 160                 {
 161                     const OUString& rAdd( pAtoms->getString( ATOM_FAMILYNAME, *name_it ) );
 162                     if( !rAdd.isEmpty() )
 163                     {
 164                         aLine.append(';');
 165                         aLine.append(OUStringToOString(rAdd, RTL_TEXTENCODING_UTF8));
 166                     }
 167                 }
 168                 aStream.WriteLine(aLine.makeStringAndClear());
 169
 170                 const OUString& rPSName( pAtoms->getString( ATOM_PSNAME, (*it)->m_nPSName ) );
 171                 aLine.append(nSubEntry);
 172                 aLine.append(';');
 173                 aLine.append(OUStringToOString(rPSName, RTL_TEXTENCODING_UTF8));
 174                 aLine.append(';');
 175                 aLine.append(static_cast<sal_Int32>((*it)->m_eItalic));
 176                 aLine.append(';');
 177                 aLine.append(static_cast<sal_Int32>((*it)->m_eWeight));
 178                 aLine.append(';');
 179                 aLine.append(static_cast<sal_Int32>((*it)->m_eWidth));
 180                 aLine.append(';');
 181                 aLine.append(static_cast<sal_Int32>((*it)->m_ePitch));
 182                 aLine.append(';');
 183                 aLine.append(static_cast<sal_Int32>((*it)->m_aEncoding));
 184                 aLine.append(';');
 185                 aLine.append(static_cast<sal_Int32>((*it)->m_nAscend));
 186                 aLine.append(';');
 187                 aLine.append(static_cast<sal_Int32>((*it)->m_nDescend));
 188                 aLine.append(';');
 189                 aLine.append(static_cast<sal_Int32>((*it)->m_nLeading));
 190                 aLine.append(';');
 191                 aLine.append((*it)->m_bHaveVerticalSubstitutedGlyphs ? '1' : '0');
 192                 aLine.append(';');
 193                 aLine.append(static_cast<sal_Int32>((*it)->m_aGlobalMetricX.width ));
 194                 aLine.append(';');
 195                 aLine.append(static_cast<sal_Int32>((*it)->m_aGlobalMetricX.height));
 196                 aLine.append(';');
 197                 aLine.append(static_cast<sal_Int32>((*it)->m_aGlobalMetricY.width ));
 198                 aLine.append(';');
 199                 aLine.append(static_cast<sal_Int32>((*it)->m_aGlobalMetricY.height));
 200                 aLine.append(';');
 201                 aLine.append((*it)->m_bUserOverride ? '1' : '0');
 202                 aLine.append(';');
 203                 aLine.append(static_cast<sal_Int32>(0));
 204                 aLine.append(';');
 205                 aLine.append(static_cast<sal_Int32>(0));
 206
 207                 switch( (*it)->m_eType )
 208                 {
 209                     case fonttype::Type1:
 210                         aLine.append(';');
 211                         aLine.append(static_cast<const PrintFontManager::Type1FontFile*>(*it)->m_aMetricFile);
 212                         break;
 213                     case fonttype::TrueType:
 214                         aLine.append(';');
 215                         aLine.append(static_cast<sal_Int32>(static_cast<const PrintFontManager::TrueTypeFontFile*>(*it)->m_nTypeFlags));
 216                         break;
 217                     default: break;
 218                 }
 219                 if( !(*it)->m_aStyleName.isEmpty() )
 220                 {
 221                     aLine.append(';');
 222                     aLine.append(OUStringToOString((*it)->m_aStyleName, RTL_TEXTENCODING_UTF8));
 223                 }
 224                 aStream.WriteLine(aLine.makeStringAndClear());
 225             }
 226             aStream.WriteLine(OString());
 227         }
 228     }
 229     m_bDoFlush = false;
 230 }
 231
 232 /*
 233  * FontCache::read
 234  */
 235
 236 void FontCache::read()
 237 {
 238     PrintFontManager& rManager( PrintFontManager::get() );
 239     MultiAtomProvider* pAtoms = rManager.m_pAtoms;
 240
 241     SvFileStream aStream( m_aCacheFile, STREAM_READ );
 242     if( ! aStream.IsOpen() )
 243     {
 244 #if OSL_DEBUG_LEVEL > 1
 245         fprintf( stderr, "FontCache::read: opening cache file %s failed\n", OUStringToOString(m_aCacheFile, osl_getThreadTextEncoding()).getStr() );
 246 #endif
 247         return;
 248     }
 249
 250
 251     OString aLine;
 252     aStream.ReadLine( aLine );
 253     if ( !(aLine == CACHE_MAGIC) )
 254     {
 255         #if OSL_DEBUG_LEVEL >1
 256         fprintf( stderr, "FontCache::read: cache file %s fails magic test\n", OUStringToOString(m_aCacheFile, osl_getThreadTextEncoding()).getStr() );
 257         #endif
 258         return;
 259     }
 260
 261     int nDir = 0;
 262     FontDirMap* pDir = NULL;
 263     bool bKeepOnlyUserOverridden = false;
 264     do
 265     {
 266         aStream.ReadLine( aLine );
 267         if( aLine.startsWith("FontCacheDirectory:") ||
 268             aLine.startsWith("EmptyFontCacheDirectory:") )
 269         {
 270             bool bEmpty = aLine.startsWith("Empty");
 271             sal_Int32 nSearchIndex = bEmpty ? 24 : 19;
 272
 273             OString aDir;
 274             sal_Int64 nTimestamp = 0;
 275             sal_Int32 nTEnd = aLine.indexOf( ':', nSearchIndex );
 276             if( nTEnd != -1 )
 277             {
 278                 OString aTimeStamp = aLine.copy( nSearchIndex, nTEnd - nSearchIndex );
 279                 nTimestamp = aTimeStamp.toInt64();
 280                 aDir = aLine.copy( nTEnd+1 );
 281             }
 282             else
 283             {
 284                 // invalid format, remove
 285                 pDir = NULL;
 286                 nDir = 0;
 287                 m_bDoFlush = true;
 288                 continue;
 289             }
 290
 291             // is the directory modified ?
 292             struct stat aStat;
 293             if( stat( aDir.getStr(), &aStat )               ||
 294                 ! S_ISDIR(aStat.st_mode) )
 295             {
 296                 // remove outdated cache data
 297                 pDir = NULL;
 298                 nDir = 0;
 299                 m_bDoFlush = true;
 300                 continue;
 301             }
 302             else
 303             {
 304                 nDir = rManager.getDirectoryAtom( aDir, true );
 305                 m_aCache[ nDir ].m_nTimestamp = (sal_Int64)aStat.st_mtime;
 306                 m_aCache[ nDir ].m_bNoFiles = bEmpty;
 307                 pDir = bEmpty ? NULL : &m_aCache[ nDir ].m_aEntries;
 308                 bKeepOnlyUserOverridden = ((sal_Int64)aStat.st_mtime != nTimestamp);
 309                 m_aCache[ nDir ].m_bUserOverrideOnly = bKeepOnlyUserOverridden;
 310             }
 311         }
 312         else if( pDir && aLine.startsWith("File:") )
 313         {
 314             OString aFile( aLine.copy( 5 ) );
 315             aStream.ReadLine( aLine );
 316
 317             const char* pLine = aLine.getStr();
 318
 319             fonttype::type eType = (fonttype::type)atoi( pLine );
 320             if( eType != fonttype::TrueType     &&
 321                 eType != fonttype::Type1        &&
 322                 eType != fonttype::Builtin
 323                 )
 324                 continue;
 325             while( *pLine && *pLine != ';' )
 326                 pLine++;
 327             if( *pLine != ';' )
 328                 continue;
 329
 330             pLine++;
 331             sal_Int32 nFonts = atoi( pLine );
 332             for( int n = 0; n < nFonts; n++ )
 333             {
 334                 aStream.ReadLine( aLine );
 335                 pLine = aLine.getStr();
 336                 int nLen = aLine.getLength();
 337
 338                 PrintFontManager::PrintFont* pFont = NULL;
 339                 switch( eType )
 340                 {
 341                     case fonttype::TrueType:
 342                         pFont = new PrintFontManager::TrueTypeFontFile();
 343                         break;
 344                     case fonttype::Type1:
 345                         pFont = new PrintFontManager::Type1FontFile();
 346                         break;
 347                     case fonttype::Builtin:
 348                         pFont = new PrintFontManager::BuiltinFont();
 349                         break;
 350                     default: break;
 351                 }
 352
 353                 sal_Int32 nIndex;
 354
 355                 for( nIndex = 0; nIndex < nLen && pLine[nIndex] != ';'; nIndex++ )
 356                     ;
 357
 358                 pFont->m_nFamilyName = pAtoms->getAtom( ATOM_FAMILYNAME,
 359                                                         OUString( pLine, nIndex, RTL_TEXTENCODING_UTF8 ),
 360                                                         sal_True );
 361                 while( nIndex < nLen )
 362                 {
 363                     sal_Int32 nLastIndex = nIndex+1;
 364                     for( nIndex = nLastIndex ; nIndex < nLen && pLine[nIndex] != ';'; nIndex++ )
 365                         ;
 366                     if( nIndex - nLastIndex )
 367                     {
 368                         OUString aAlias( pLine+nLastIndex, nIndex-nLastIndex, RTL_TEXTENCODING_UTF8 );
 369                         pFont->m_aAliases.push_back( pAtoms->getAtom( ATOM_FAMILYNAME, aAlias, sal_True ) );
 370                     }
 371                 }
 372                 aStream.ReadLine( aLine );
 373                 pLine = aLine.getStr();
 374                 nLen = aLine.getLength();
 375
 376                 // get up to 20 token positions
 377                 const int nMaxTokens = 20;
 378                 int nTokenPos[nMaxTokens];
 379                 nTokenPos[0] = 0;
 380                 int nTokens = 1;
 381                 for( int i = 0; i < nLen; i++ )
 382                 {
 383                     if( pLine[i] == ';' )
 384                     {
 385                         nTokenPos[nTokens++] = i+1;
 386                         if( nTokens == nMaxTokens )
 387                             break;
 388                     }
 389                 }
 390                 if( nTokens < 18 )
 391                 {
 392                     delete pFont;
 393                     continue;
 394                 }
 395                 int nCollEntry      = atoi( pLine );
 396                 pFont->m_nPSName    = pAtoms->getAtom( ATOM_PSNAME, OUString( pLine + nTokenPos[1], nTokenPos[2]-nTokenPos[1]-1, RTL_TEXTENCODING_UTF8 ), sal_True );
 397                 pFont->m_eItalic    = (FontItalic)atoi( pLine+nTokenPos[2] );
 398                 pFont->m_eWeight    = (FontWeight)atoi( pLine+nTokenPos[3] );
 399                 pFont->m_eWidth     = (FontWidth)atoi( pLine+nTokenPos[4] );
 400                 pFont->m_ePitch     = (FontPitch)atoi( pLine+nTokenPos[5] );
 401                 pFont->m_aEncoding  = (rtl_TextEncoding)atoi( pLine+nTokenPos[6] );
 402                 pFont->m_nAscend    = atoi( pLine + nTokenPos[7] );
 403                 pFont->m_nDescend   = atoi( pLine + nTokenPos[8] );
 404                 pFont->m_nLeading   = atoi( pLine + nTokenPos[9] );
 405                 pFont->m_bHaveVerticalSubstitutedGlyphs
 406                                     = (atoi( pLine + nTokenPos[10] ) != 0);
 407                 pFont->m_aGlobalMetricX.width
 408                                     = atoi( pLine + nTokenPos[11] );
 409                 pFont->m_aGlobalMetricX.height
 410                                     = atoi( pLine + nTokenPos[12] );
 411                 pFont->m_aGlobalMetricY.width
 412                                     = atoi( pLine + nTokenPos[13] );
 413                 pFont->m_aGlobalMetricY.height
 414                                     = atoi( pLine + nTokenPos[14] );
 415                 pFont->m_bUserOverride
 416                                     = (atoi( pLine + nTokenPos[15] ) != 0);
 417                 int nStyleTokenNr = 18;
 418                 switch( eType )
 419                 {
 420                     case fonttype::TrueType:
 421                         static_cast<PrintFontManager::TrueTypeFontFile*>(pFont)->m_nTypeFlags = atoi( pLine + nTokenPos[18] );
 422                         static_cast<PrintFontManager::TrueTypeFontFile*>(pFont)->m_nCollectionEntry = nCollEntry;
 423                         static_cast<PrintFontManager::TrueTypeFontFile*>(pFont)->m_nDirectory = nDir;
 424                         static_cast<PrintFontManager::TrueTypeFontFile*>(pFont)->m_aFontFile = aFile;
 425                         nStyleTokenNr++;
 426                         break;
 427                     case fonttype::Type1:
 428                     {
 429                         int nTokLen = (nTokens > 19 ) ? nTokenPos[19]-nTokenPos[18]-1 : nLen - nTokenPos[18];
 430                         static_cast<PrintFontManager::Type1FontFile*>(pFont)->m_aMetricFile = OString( pLine + nTokenPos[18], nTokLen );
 431                         static_cast<PrintFontManager::Type1FontFile*>(pFont)->m_nDirectory = nDir;
 432                         static_cast<PrintFontManager::Type1FontFile*>(pFont)->m_aFontFile = aFile;
 433                         nStyleTokenNr++;
 434                     }
 435                     break;
 436                     case fonttype::Builtin:
 437                         static_cast<PrintFontManager::BuiltinFont*>(pFont)->m_nDirectory = nDir;
 438                         static_cast<PrintFontManager::BuiltinFont*>(pFont)->m_aMetricFile = aFile;
 439                         break;
 440                     default: break;
 441                 }
 442                 if( nTokens > nStyleTokenNr )
 443                     pFont->m_aStyleName = OUString::intern( pLine + nTokenPos[nStyleTokenNr],
 444                                                             nLen - nTokenPos[nStyleTokenNr],
 445                                                             RTL_TEXTENCODING_UTF8 );
 446
 447                 bool bObsolete = false;
 448                 if( bKeepOnlyUserOverridden )
 449                 {
 450                     if( pFont->m_bUserOverride )
 451                     {
 452                         OStringBuffer aFilePath(rManager.getDirectory(nDir));
 453                         aFilePath.append('/').append(aFile);
 454                         struct stat aStat;
 455                         if( stat( aFilePath.getStr(), &aStat )   ||
 456                             ! S_ISREG( aStat.st_mode )              ||
 457                             aStat.st_size < 16 )
 458                         {
 459                             bObsolete = true;
 460                         }
 461                         #if OSL_DEBUG_LEVEL > 2
 462                         else
 463                             fprintf( stderr, "keeping file %s in outdated cache entry due to user override\n",
 464                                      aFilePath.getStr() );
 465                         #endif
 466                     }
 467                     else
 468                         bObsolete = true;
 469                 }
 470                 if( bObsolete )
 471                 {
 472                     m_bDoFlush = true;
 473 #if OSL_DEBUG_LEVEL > 2
 474                     fprintf( stderr, "removing obsolete font %s\n", aFile.getStr() );
 475 #endif
 476                     delete pFont;
 477                     continue;
 478                 }
 479
 480                 FontCacheEntry& rEntry = (*pDir)[aFile].m_aEntry;
 481                 rEntry.push_back( pFont );
 482             }
 483         }
 484     } while( ! aStream.IsEof() );
 485 }
 486
 487 /*
 488  *  FontCache::copyPrintFont
 489  */
 490 void FontCache::copyPrintFont( const PrintFontManager::PrintFont* pFrom, PrintFontManager::PrintFont* pTo ) const
 491 {
 492     if( pFrom->m_eType != pTo->m_eType )
 493         return;
 494     switch( pFrom->m_eType )
 495     {
 496         case fonttype::TrueType:
 497             static_cast<PrintFontManager::TrueTypeFontFile*>(pTo)->m_nDirectory = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFrom)->m_nDirectory;
 498             static_cast<PrintFontManager::TrueTypeFontFile*>(pTo)->m_aFontFile = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFrom)->m_aFontFile;
 499             static_cast<PrintFontManager::TrueTypeFontFile*>(pTo)->m_nCollectionEntry = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFrom)->m_nCollectionEntry;
 500             static_cast<PrintFontManager::TrueTypeFontFile*>(pTo)->m_nTypeFlags = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFrom)->m_nTypeFlags;
 501             break;
 502         case fonttype::Type1:
 503             static_cast<PrintFontManager::Type1FontFile*>(pTo)->m_nDirectory = static_cast<const PrintFontManager::Type1FontFile*>(pFrom)->m_nDirectory;
 504             static_cast<PrintFontManager::Type1FontFile*>(pTo)->m_aFontFile = static_cast<const PrintFontManager::Type1FontFile*>(pFrom)->m_aFontFile;
 505             static_cast<PrintFontManager::Type1FontFile*>(pTo)->m_aMetricFile = static_cast<const PrintFontManager::Type1FontFile*>(pFrom)->m_aMetricFile;
 506             break;
 507         case fonttype::Builtin:
 508             static_cast<PrintFontManager::BuiltinFont*>(pTo)->m_nDirectory = static_cast<const PrintFontManager::BuiltinFont*>(pFrom)->m_nDirectory;
 509             static_cast<PrintFontManager::BuiltinFont*>(pTo)->m_aMetricFile = static_cast<const PrintFontManager::BuiltinFont*>(pFrom)->m_aMetricFile;
 510             break;
 511         default: break;
 512     }
 513     pTo->m_nFamilyName      = pFrom->m_nFamilyName;
 514     pTo->m_aStyleName       = pFrom->m_aStyleName;
 515     pTo->m_aAliases         = pFrom->m_aAliases;
 516     pTo->m_nPSName          = pFrom->m_nPSName;
 517     pTo->m_eItalic          = pFrom->m_eItalic;
 518     pTo->m_eWeight          = pFrom->m_eWeight;
 519     pTo->m_eWidth           = pFrom->m_eWidth;
 520     pTo->m_ePitch           = pFrom->m_ePitch;
 521     pTo->m_aEncoding        = pFrom->m_aEncoding;
 522     pTo->m_aGlobalMetricX   = pFrom->m_aGlobalMetricX;
 523     pTo->m_aGlobalMetricY   = pFrom->m_aGlobalMetricY;
 524     pTo->m_nAscend          = pFrom->m_nAscend;
 525     pTo->m_nDescend         = pFrom->m_nDescend;
 526     pTo->m_nLeading         = pFrom->m_nLeading;
 527     pTo->m_nXMin            = pFrom->m_nXMin;
 528     pTo->m_nYMin            = pFrom->m_nYMin;
 529     pTo->m_nXMax            = pFrom->m_nXMax;
 530     pTo->m_nYMax            = pFrom->m_nYMax;
 531     pTo->m_bHaveVerticalSubstitutedGlyphs = pFrom->m_bHaveVerticalSubstitutedGlyphs;
 532     pTo->m_bUserOverride    = pFrom->m_bUserOverride;
 533 }
 534
 535 /*
 536  *  FontCache::equalsPrintFont
 537  */
 538 bool FontCache::equalsPrintFont( const PrintFontManager::PrintFont* pLeft, PrintFontManager::PrintFont* pRight ) const
 539 {
 540     if( pLeft->m_eType != pRight->m_eType )
 541         return false;
 542     switch( pLeft->m_eType )
 543     {
 544         case fonttype::TrueType:
 545         {
 546             const PrintFontManager::TrueTypeFontFile* pLT = static_cast<const PrintFontManager::TrueTypeFontFile*>(pLeft);
 547             const PrintFontManager::TrueTypeFontFile* pRT = static_cast<const PrintFontManager::TrueTypeFontFile*>(pRight);
 548             if( pRT->m_nDirectory       != pLT->m_nDirectory        ||
 549                 pRT->m_aFontFile        != pLT->m_aFontFile         ||
 550                 pRT->m_nCollectionEntry != pLT->m_nCollectionEntry  ||
 551                 pRT->m_nTypeFlags       != pLT->m_nTypeFlags )
 552                 return false;
 553         }
 554         break;
 555         case fonttype::Type1:
 556         {
 557             const PrintFontManager::Type1FontFile* pLT = static_cast<const PrintFontManager::Type1FontFile*>(pLeft);
 558             const PrintFontManager::Type1FontFile* pRT = static_cast<const PrintFontManager::Type1FontFile*>(pRight);
 559             if( pRT->m_nDirectory       != pLT->m_nDirectory        ||
 560                 pRT->m_aFontFile        != pLT->m_aFontFile         ||
 561                 pRT->m_aMetricFile      != pLT->m_aMetricFile )
 562                 return false;
 563         }
 564         break;
 565         case fonttype::Builtin:
 566         {
 567             const PrintFontManager::BuiltinFont* pLT = static_cast<const PrintFontManager::BuiltinFont*>(pLeft);
 568             const PrintFontManager::BuiltinFont* pRT = static_cast<const PrintFontManager::BuiltinFont*>(pRight);
 569             if( pRT->m_nDirectory       != pLT->m_nDirectory        ||
 570                 pRT->m_aMetricFile      != pLT->m_aMetricFile )
 571                 return false;
 572         }
 573         break;
 574         default: break;
 575     }
 576     if( pRight->m_nFamilyName       != pLeft->m_nFamilyName     ||
 577         pRight->m_aStyleName        != pLeft->m_aStyleName      ||
 578         pRight->m_nPSName           != pLeft->m_nPSName         ||
 579         pRight->m_eItalic           != pLeft->m_eItalic         ||
 580         pRight->m_eWeight           != pLeft->m_eWeight         ||
 581         pRight->m_eWidth            != pLeft->m_eWidth          ||
 582         pRight->m_ePitch            != pLeft->m_ePitch          ||
 583         pRight->m_aEncoding         != pLeft->m_aEncoding       ||
 584         pRight->m_aGlobalMetricX    != pLeft->m_aGlobalMetricX  ||
 585         pRight->m_aGlobalMetricY    != pLeft->m_aGlobalMetricY  ||
 586         pRight->m_nAscend           != pLeft->m_nAscend         ||
 587         pRight->m_nDescend          != pLeft->m_nDescend        ||
 588         pRight->m_nLeading          != pLeft->m_nLeading        ||
 589         pRight->m_nXMin             != pLeft->m_nXMin           ||
 590         pRight->m_nYMin             != pLeft->m_nYMin           ||
 591         pRight->m_nXMax             != pLeft->m_nXMax           ||
 592         pRight->m_nYMax             != pLeft->m_nYMax           ||
 593         pRight->m_bHaveVerticalSubstitutedGlyphs != pLeft->m_bHaveVerticalSubstitutedGlyphs ||
 594         pRight->m_bUserOverride     != pLeft->m_bUserOverride
 595         )
 596         return false;
 597     std::list< int >::const_iterator lit, rit;
 598     for( lit = pLeft->m_aAliases.begin(), rit = pRight->m_aAliases.begin();
 599          lit != pLeft->m_aAliases.end() && rit != pRight->m_aAliases.end() && (*lit) == (*rit);
 600          ++lit, ++rit )
 601         ;
 602     return lit == pLeft->m_aAliases.end() && rit == pRight->m_aAliases.end();
 603 }
 604
 605 /*
 606  *  FontCache::clonePrintFont
 607  */
 608 PrintFontManager::PrintFont* FontCache::clonePrintFont( const PrintFontManager::PrintFont* pOldFont ) const
 609 {
 610     PrintFontManager::PrintFont* pFont = NULL;
 611     switch( pOldFont->m_eType )
 612     {
 613         case fonttype::TrueType:
 614             pFont = new PrintFontManager::TrueTypeFontFile();
 615             break;
 616         case fonttype::Type1:
 617             pFont = new PrintFontManager::Type1FontFile();
 618             break;
 619         case fonttype::Builtin:
 620             pFont = new PrintFontManager::BuiltinFont();
 621             break;
 622         default: break;
 623     }
 624     if( pFont )
 625     {
 626         copyPrintFont( pOldFont, pFont );
 627     }
 628     return pFont;
 629  }
 630
 631 /*
 632  *  FontCache::getFontCacheFile
 633  */
 634 bool FontCache::getFontCacheFile( int nDirID, const OString& rFile, list< PrintFontManager::PrintFont* >& rNewFonts ) const
 635 {
 636     bool bSuccess = false;
 637
 638     FontCacheData::const_iterator dir = m_aCache.find( nDirID );
 639     if( dir != m_aCache.end() )
 640     {
 641         FontDirMap::const_iterator entry = dir->second.m_aEntries.find( rFile );
 642         if( entry != dir->second.m_aEntries.end() )
 643         {
 644             for( FontCacheEntry::const_iterator font = entry->second.m_aEntry.begin(); font != entry->second.m_aEntry.end(); ++font )
 645             {
 646                 bSuccess = true;
 647                 PrintFontManager::PrintFont* pFont = clonePrintFont( *font );
 648                 rNewFonts.push_back( pFont );
 649             }
 650         }
 651     }
 652     return bSuccess;
 653 }
 654
 655 /*
 656  *  FontCache::updateFontCacheEntry
 657  */
 658 void FontCache::updateFontCacheEntry( const PrintFontManager::PrintFont* pFont, bool bFlush )
 659 {
 660     OString aFile;
 661     int nDirID = 0;
 662     switch( pFont->m_eType )
 663     {
 664         case fonttype::TrueType:
 665             nDirID = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFont)->m_nDirectory;
 666             aFile = static_cast<const PrintFontManager::TrueTypeFontFile*>(pFont)->m_aFontFile;
 667             break;
 668         case fonttype::Type1:
 669             nDirID = static_cast<const PrintFontManager::Type1FontFile*>(pFont)->m_nDirectory;
 670             aFile = static_cast<const PrintFontManager::Type1FontFile*>(pFont)->m_aFontFile;
 671             break;
 672         case fonttype::Builtin:
 673             nDirID = static_cast<const PrintFontManager::BuiltinFont*>(pFont)->m_nDirectory;
 674             aFile = static_cast<const PrintFontManager::BuiltinFont*>(pFont)->m_aMetricFile;
 675             break;
 676         default:
 677             return;
 678     }
 679     FontCacheData::const_iterator dir = m_aCache.find( nDirID );
 680     FontDirMap::const_iterator entry;
 681     FontCacheEntry::const_iterator font;
 682     PrintFontManager::PrintFont* pCacheFont = NULL;
 683
 684     if( dir != m_aCache.end() )
 685     {
 686         entry = dir->second.m_aEntries.find( aFile );
 687         if( entry != dir->second.m_aEntries.end() )
 688         {
 689             for( font = entry->second.m_aEntry.begin(); font != entry->second.m_aEntry.end(); ++font )
 690             {
 691                 if( (*font)->m_eType == pFont->m_eType &&
 692                     ( (*font)->m_eType != fonttype::TrueType ||
 693                       static_cast<const PrintFontManager::TrueTypeFontFile*>(*font)->m_nCollectionEntry == static_cast<const PrintFontManager::TrueTypeFontFile*>(pFont)->m_nCollectionEntry
 694                       ) )
 695                     break;
 696             }
 697             if( font != entry->second.m_aEntry.end() )
 698                 pCacheFont = *font;
 699         }
 700     }
 701     else
 702         createCacheDir( nDirID );
 703
 704     if( pCacheFont )
 705     {
 706         if( ! equalsPrintFont( pFont, pCacheFont ) )
 707         {
 708             copyPrintFont( pFont, pCacheFont );
 709             m_bDoFlush = true;
 710         }
 711     }
 712     else
 713     {
 714         pCacheFont = clonePrintFont( pFont );
 715         m_aCache[nDirID].m_aEntries[aFile].m_aEntry.push_back( pCacheFont );
 716         m_bDoFlush = true;
 717     }
 718     if( bFlush )
 719         flush();
 720 }
 721
 722 /*
 723  *  FontCache::listDirectory
 724  */
 725 bool FontCache::listDirectory( const OString& rDir, std::list< PrintFontManager::PrintFont* >& rNewFonts ) const
 726 {
 727     PrintFontManager& rManager( PrintFontManager::get() );
 728     int nDirID = rManager.getDirectoryAtom( rDir );
 729
 730     FontCacheData::const_iterator dir = m_aCache.find( nDirID );
 731     bool bFound = (dir != m_aCache.end());
 732
 733     if( bFound && !dir->second.m_bNoFiles )
 734     {
 735         for( FontDirMap::const_iterator file = dir->second.m_aEntries.begin(); file != dir->second.m_aEntries.end(); ++file )
 736         {
 737             for( FontCacheEntry::const_iterator font = file->second.m_aEntry.begin(); font != file->second.m_aEntry.end(); ++font )
 738             {
 739                 PrintFontManager::PrintFont* pFont = clonePrintFont( *font );
 740                 rNewFonts.push_back( pFont );
 741             }
 742         }
 743     }
 744     return bFound;
 745 }
 746
 747 /*
 748  *  FontCache::listDirectory
 749  */
 750 bool FontCache::scanAdditionalFiles( const OString& rDir )
 751 {
 752     PrintFontManager& rManager( PrintFontManager::get() );
 753     int nDirID = rManager.getDirectoryAtom( rDir );
 754     FontCacheData::const_iterator dir = m_aCache.find( nDirID );
 755     bool bFound = (dir != m_aCache.end());
 756
 757     return (bFound && dir->second.m_bUserOverrideOnly);
 758 }
 759
 760 /*
 761  *  FontCache::createCacheDir
 762  */
 763 void FontCache::createCacheDir( int nDirID )
 764 {
 765     PrintFontManager& rManager( PrintFontManager::get() );
 766
 767     const OString& rDir = rManager.getDirectory( nDirID );
 768     struct stat aStat;
 769     if( ! stat( rDir.getStr(), &aStat ) )
 770         m_aCache[nDirID].m_nTimestamp = (sal_Int64)aStat.st_mtime;
 771 }
 772
 773 /*
 774  *  FontCache::markEmptyDir
 775  */
 776 void FontCache::markEmptyDir( int nDirID, bool bNoFiles )
 777 {
 778     createCacheDir( nDirID );
 779     m_aCache[nDirID].m_bNoFiles = bNoFiles;
 780     m_bDoFlush = true;
 781 }
 782
 783 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */