vcl/source/gdi/embeddedfontshelper.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
  10 #include <memory>
  11 #include <config_folders.h>
  12 #include <config_eot.h>
  13
  14 #include <osl/file.hxx>
  15 #include <rtl/bootstrap.hxx>
  16 #include <sal/log.hxx>
  17 #include <vcl/svapp.hxx>
  18 #include <vcl/embeddedfontshelper.hxx>
  19 #include <com/sun/star/io/XInputStream.hpp>
  20
  21 #include <outdev.h>
  22 #include <PhysicalFontCollection.hxx>
  23 #include <salgdi.hxx>
  24 #include <sft.hxx>
  25
  26
  27 #if ENABLE_EOT
  28 extern "C"
  29 {
  30 namespace libeot
  31 {
  32 #include <libeot/libeot.h>
  33 } // namespace libeot
  34 } // extern "C"
  35 #endif
  36
  37 using namespace com::sun::star;
  38 using namespace vcl;
  39
  40 static void clearDir( const OUString& path )
  41 {
  42     osl::Directory dir( path );
  43     if( dir.reset() == osl::Directory::E_None )
  44     {
  45         for(;;)
  46         {
  47             osl::DirectoryItem item;
  48             if( dir.getNextItem( item ) != osl::Directory::E_None )
  49                 break;
  50             osl::FileStatus status( osl_FileStatus_Mask_FileURL );
  51             if( item.getFileStatus( status ) == osl::File::E_None )
  52                 osl::File::remove( status.getFileURL());
  53         }
  54     }
  55 }
  56
  57 void EmbeddedFontsHelper::clearTemporaryFontFiles()
  58 {
  59     OUString path = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE( "bootstrap") "::UserInstallation}";
  60     rtl::Bootstrap::expandMacros( path );
  61     path += "/user/temp/embeddedfonts/";
  62     clearDir( path + "fromdocs/" );
  63     clearDir( path + "fromsystem/" );
  64 }
  65
  66 bool EmbeddedFontsHelper::addEmbeddedFont( const uno::Reference< io::XInputStream >& stream, const OUString& fontName,
  67     const char* extra, std::vector< unsigned char > const & key, bool eot )
  68 {
  69     OUString fileUrl = EmbeddedFontsHelper::fileUrlForTemporaryFont( fontName, extra );
  70     osl::File file( fileUrl );
  71     switch( file.open( osl_File_OpenFlag_Create | osl_File_OpenFlag_Write ))
  72     {
  73         case osl::File::E_None:
  74             break; // ok
  75         case osl::File::E_EXIST:
  76             return true; // Assume it's already been added correctly.
  77         default:
  78             SAL_WARN( "vcl.fonts", "Cannot open file for temporary font" );
  79             return false;
  80     }
  81     size_t keyPos = 0;
  82     std::vector< char > fontData;
  83     fontData.reserve( 1000000 );
  84     for(;;)
  85     {
  86         uno::Sequence< sal_Int8 > buffer;
  87         sal_uInt64 read = stream->readBytes( buffer, 1024 );
  88         for( sal_uInt64 pos = 0;
  89              pos < read && keyPos < key.size();
  90              ++pos )
  91             buffer[ pos ] ^= key[ keyPos++ ];
  92         // if eot, don't write the file out yet, since we need to unpack it first.
  93         if( !eot && read > 0 )
  94         {
  95             sal_uInt64 writtenTotal = 0;
  96             while( writtenTotal < read )
  97             {
  98                 sal_uInt64 written;
  99                 file.write( buffer.getConstArray(), read, written );
 100                 writtenTotal += written;
 101             }
 102         }
 103         fontData.insert( fontData.end(), buffer.getConstArray(), buffer.getConstArray() + read );
 104         if( read <= 0 )
 105             break;
 106     }
 107     bool sufficientFontRights(false);
 108 #if ENABLE_EOT
 109     if( eot )
 110     {
 111         unsigned uncompressedFontSize = 0;
 112         unsigned char *nakedPointerToUncompressedFont = nullptr;
 113         libeot::EOTMetadata eotMetadata;
 114         libeot::EOTError uncompressError =
 115             libeot::EOT2ttf_buffer( reinterpret_cast<unsigned char *>(fontData.data()), fontData.size(), &eotMetadata, &nakedPointerToUncompressedFont, &uncompressedFontSize );
 116         std::shared_ptr<unsigned char> uncompressedFont( nakedPointerToUncompressedFont, libeot::EOTfreeBuffer );
 117         if( uncompressError != libeot::EOT_SUCCESS )
 118         {
 119             SAL_WARN( "vcl.fonts", "Failed to uncompress font" );
 120             osl::File::remove( fileUrl );
 121             return false;
 122         }
 123         sal_uInt64 writtenTotal = 0;
 124         while( writtenTotal < uncompressedFontSize )
 125         {
 126             sal_uInt64 written;
 127             if( file.write( uncompressedFont.get() + writtenTotal, uncompressedFontSize - writtenTotal, written ) != osl::File::E_None )
 128             {
 129                 SAL_WARN( "vcl.fonts", "Error writing temporary font file" );
 130                 osl::File::remove( fileUrl );
 131                 return false;
 132             }
 133             writtenTotal += written;
 134         }
 135         sufficientFontRights = libeot::EOTcanLegallyEdit( &eotMetadata );
 136         libeot::EOTfreeMetadata( &eotMetadata );
 137     }
 138 #endif
 139
 140     if( file.close() != osl::File::E_None )
 141     {
 142         SAL_WARN( "vcl.fonts", "Writing temporary font file failed" );
 143         osl::File::remove( fileUrl );
 144         return false;
 145     }
 146     if( !eot )
 147     {
 148         sufficientFontRights = sufficientTTFRights(fontData.data(), fontData.size(), FontRights::EditingAllowed);
 149     }
 150     if( !sufficientFontRights )
 151     {
 152         // It would be actually better to open the document in read-only mode in this case,
 153         // warn the user about this, and provide a button to drop the font(s) in order
 154         // to switch to editing.
 155         SAL_INFO( "vcl.fonts", "Ignoring embedded font that is not usable for editing" );
 156         osl::File::remove( fileUrl );
 157         return false;
 158     }
 159     m_aAccumulatedFonts.emplace_back(std::make_pair(fontName, fileUrl));
 160     return true;
 161 }
 162
 163 namespace
 164 {
 165     struct UpdateFontsGuard
 166     {
 167         UpdateFontsGuard()
 168         {
 169             OutputDevice::ImplClearAllFontData(true);
 170         }
 171
 172         ~UpdateFontsGuard()
 173         {
 174             OutputDevice::ImplRefreshAllFontData(true);
 175         }
 176     };
 177 }
 178
 179 void EmbeddedFontsHelper::activateFonts()
 180 {
 181     if (m_aAccumulatedFonts.empty())
 182         return;
 183     UpdateFontsGuard aUpdateFontsGuard;
 184     for (const auto& rEntry : m_aAccumulatedFonts)
 185         EmbeddedFontsHelper::activateFont(rEntry.first, rEntry.second);
 186     m_aAccumulatedFonts.clear();
 187 }
 188
 189 OUString EmbeddedFontsHelper::fileUrlForTemporaryFont( const OUString& fontName, const char* extra )
 190 {
 191     OUString path = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE( "bootstrap") "::UserInstallation}";
 192     rtl::Bootstrap::expandMacros( path );
 193     path += "/user/temp/embeddedfonts/fromdocs/";
 194     osl::Directory::createPath( path );
 195     OUString filename = fontName;
 196     static int uniqueCounter = 0;
 197     if( strcmp( extra, "?" ) == 0 )
 198         filename += OUString::number( uniqueCounter++ );
 199     else
 200         filename += OStringToOUString( extra, RTL_TEXTENCODING_ASCII_US );
 201     filename += ".ttf"; // TODO is it always ttf?
 202     return path + filename;
 203 }
 204
 205 void EmbeddedFontsHelper::activateFont( const OUString& fontName, const OUString& fileUrl )
 206 {
 207     OutputDevice *pDevice = Application::GetDefaultDevice();
 208     pDevice->AddTempDevFont(fileUrl, fontName);
 209 }
 210
 211 // Check if it's (legally) allowed to embed the font file into a document
 212 // (ttf has a flag allowing this). PhysicalFontFace::IsEmbeddable() appears
 213 // to have a different meaning (guessing from code, IsSubsettable() might
 214 // possibly mean it's ttf, while IsEmbeddable() might mean it's type1).
 215 // So just try to open the data as ttf and see.
 216 bool EmbeddedFontsHelper::sufficientTTFRights( const void* data, tools::Long size, FontRights rights )
 217 {
 218     TrueTypeFont* font;
 219     if( OpenTTFontBuffer( data, size, 0 /*TODO*/, &font ) == SFErrCodes::Ok )
 220     {
 221         TTGlobalFontInfo info;
 222         GetTTGlobalFontInfo( font, &info );
 223         CloseTTFont( font );
 224         // https://www.microsoft.com/typography/otspec/os2.htm#fst
 225         int copyright = info.typeFlags;
 226         switch( rights )
 227         {
 228             case FontRights::ViewingAllowed:
 229                 // Embedding not restricted completely.
 230                 return ( copyright & 0x02 ) != 0x02;
 231             case FontRights::EditingAllowed:
 232                 // Font is installable or editable.
 233                 return copyright == 0 || ( copyright & 0x08 );
 234         }
 235     }
 236     return true; // no known restriction
 237 }
 238
 239 OUString EmbeddedFontsHelper::fontFileUrl( std::u16string_view familyName, FontFamily family, FontItalic italic,
 240     FontWeight weight, FontPitch pitch, FontRights rights )
 241 {
 242     OUString path = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE( "bootstrap") "::UserInstallation}";
 243     rtl::Bootstrap::expandMacros( path );
 244     path += "/user/temp/embeddedfonts/fromsystem/";
 245     osl::Directory::createPath( path );
 246     OUString filename = OUString::Concat(familyName) + "_" + OUString::number( family ) + "_" + OUString::number( italic )
 247         + "_" + OUString::number( weight ) + "_" + OUString::number( pitch )
 248         + ".ttf"; // TODO is it always ttf?
 249     OUString url = path + filename;
 250     if( osl::File( url ).open( osl_File_OpenFlag_Read ) == osl::File::E_None ) // = exists()
 251     {
 252         // File with contents of the font file already exists, assume it's been created by a previous call.
 253         return url;
 254     }
 255     bool ok = false;
 256     SalGraphics* graphics = Application::GetDefaultDevice()->GetGraphics();
 257     PhysicalFontCollection fonts;
 258     graphics->GetDevFontList( &fonts );
 259     std::unique_ptr< ImplDeviceFontList > fontInfo( fonts.GetDeviceFontList());
 260     PhysicalFontFace* selected = nullptr;
 261     for( int i = 0;
 262          i < fontInfo->Count();
 263          ++i )
 264      {
 265         PhysicalFontFace* f = fontInfo->Get( i );
 266         if( f->GetFamilyName() == familyName )
 267         {
 268             // Ignore comparing text encodings, at least for now. They cannot be trivially compared
 269             // (e.g. UCS2 and UTF8 are technically the same characters, just have different encoding,
 270             // and just having a unicode font doesn't say what glyphs it actually contains).
 271             // It is possible that it still may be needed to do at least some checks here
 272             // for some encodings (can one font have more font files for more encodings?).
 273             if(( family == FAMILY_DONTKNOW || f->GetFamilyType() == family )
 274                 && ( italic == ITALIC_DONTKNOW || f->GetItalic() == italic )
 275                 && ( weight == WEIGHT_DONTKNOW || f->GetWeight() == weight )
 276                 && ( pitch == PITCH_DONTKNOW || f->GetPitch() == pitch ))
 277             { // Exact match, return it immediately.
 278                 selected = f;
 279                 break;
 280             }
 281             if(( f->GetFamilyType() == FAMILY_DONTKNOW || family == FAMILY_DONTKNOW || f->GetFamilyType() == family )
 282                 && ( f->GetItalic() == ITALIC_DONTKNOW || italic == ITALIC_DONTKNOW || f->GetItalic() == italic )
 283                 && ( f->GetWeight() == WEIGHT_DONTKNOW || weight == WEIGHT_DONTKNOW || f->GetWeight() == weight )
 284                 && ( f->GetPitch() == PITCH_DONTKNOW || pitch == PITCH_DONTKNOW || f->GetPitch() == pitch ))
 285             { // Some fonts specify 'DONTKNOW' for some things, still a good match, if we don't find a better one.
 286                 selected = f;
 287             }
 288         }
 289     }
 290     if( selected != nullptr )
 291     {
 292         tools::Long size;
 293         if (const void* data = graphics->GetEmbedFontData(selected, &size))
 294         {
 295             if( sufficientTTFRights( data, size, rights ))
 296             {
 297                 osl::File file( url );
 298                 if( file.open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create ) == osl::File::E_None )
 299                 {
 300                     sal_uInt64 written = 0;
 301                     sal_uInt64 totalSize = size;
 302                     bool error = false;
 303                     while( written < totalSize && !error)
 304                     {
 305                         sal_uInt64 nowWritten;
 306                         switch( file.write( static_cast< const char* >( data ) + written, size - written, nowWritten ))
 307                         {
 308                             case osl::File::E_None:
 309                                 written += nowWritten;
 310                                 break;
 311                             case osl::File::E_AGAIN:
 312                             case osl::File::E_INTR:
 313                                 break;
 314                             default:
 315                                 error = true;
 316                                 break;
 317                         }
 318                     }
 319                     file.close();
 320                     if( error )
 321                         osl::File::remove( url );
 322                     else
 323                         ok = true;
 324                 }
 325             }
 326             graphics->FreeEmbedFontData( data, size );
 327         }
 328     }
 329     return ok ? url : "";
 330 }
 331
 332 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */