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