?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update emoji autocorrect entries from po-files
[LibreOffice.git] / vcl / source / gdi / font.cxx
blobf8a1c831ac16a8462b7ead5881d2fde4e9f17265
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 #include "unotools/fontcfg.hxx"
21
22 #include "tools/stream.hxx"
23 #include "tools/vcompat.hxx"
24 #include "tools/debug.hxx"
25 #include <tools/gen.hxx>
26
27 #include "vcl/font.hxx"
28
29 #include "impfont.hxx"
30 #include "outfont.hxx"
31 #include "sft.hxx"
32
33 #include <sal/macros.h>
34
35 #include <algorithm>
36
37 using namespace vcl;
38
39 Impl_Font::Impl_Font() :
40 maColor( COL_TRANSPARENT ),
41 maFillColor( COL_TRANSPARENT ),
42 maLanguageTag( LANGUAGE_DONTKNOW ),
43 maCJKLanguageTag( LANGUAGE_DONTKNOW )
44 {
45 mnRefCount = 1;
46 meCharSet = RTL_TEXTENCODING_DONTKNOW;
47 meFamily = FAMILY_DONTKNOW;
48 mePitch = PITCH_DONTKNOW;
49 meAlign = ALIGN_TOP;
50 meWeight = WEIGHT_DONTKNOW;
51 meWidthType = WIDTH_DONTKNOW;
52 meItalic = ITALIC_NONE;
53 meUnderline = UNDERLINE_NONE;
54 meOverline = UNDERLINE_NONE;
55 meStrikeout = STRIKEOUT_NONE;
56 meRelief = RELIEF_NONE;
57 meEmphasisMark = EMPHASISMARK_NONE;
58 mnOrientation = 0;
59 mnKerning = FontKerning::NONE;
60 mbWordLine = false;
61 mbOutline = false;
62 mbShadow = false;
63 mbVertical = false;
64 mbTransparent = true;
65 mbConfigLookup = false;
66 }
67
68 Impl_Font::Impl_Font( const Impl_Font& rImplFont )
69 : maFamilyName( rImplFont.maFamilyName ),
70 maStyleName( rImplFont.maStyleName ),
71 maSize( rImplFont.maSize ),
72 maColor( rImplFont.maColor ),
73 maFillColor( rImplFont.maFillColor ),
74 maLanguageTag( rImplFont.maLanguageTag ),
75 maCJKLanguageTag( rImplFont.maCJKLanguageTag )
76 {
77 mnRefCount = 1;
78 meCharSet = rImplFont.meCharSet;
79 meFamily = rImplFont.meFamily;
80 mePitch = rImplFont.mePitch;
81 meAlign = rImplFont.meAlign;
82 meWeight = rImplFont.meWeight;
83 meWidthType = rImplFont.meWidthType;
84 meItalic = rImplFont.meItalic;
85 meUnderline = rImplFont.meUnderline;
86 meOverline = rImplFont.meOverline;
87 meStrikeout = rImplFont.meStrikeout;
88 meRelief = rImplFont.meRelief;
89 meEmphasisMark = rImplFont.meEmphasisMark;
90 mnOrientation = rImplFont.mnOrientation;
91 mnKerning = rImplFont.mnKerning;
92 mbWordLine = rImplFont.mbWordLine;
93 mbOutline = rImplFont.mbOutline;
94 mbShadow = rImplFont.mbShadow;
95 mbVertical = rImplFont.mbVertical;
96 mbTransparent = rImplFont.mbTransparent;
97 mbConfigLookup = rImplFont.mbConfigLookup;
98 }
99
100 bool Impl_Font::operator==( const Impl_Font& rOther ) const
101 {
102 // equality tests split up for easier debugging
103 if( (meWeight != rOther.meWeight)
104 || (meItalic != rOther.meItalic)
105 || (meFamily != rOther.meFamily)
106 || (mePitch != rOther.mePitch) )
107 return false;
108
109 if( (meCharSet != rOther.meCharSet)
110 || (maLanguageTag != rOther.maLanguageTag)
111 || (maCJKLanguageTag != rOther.maCJKLanguageTag)
112 || (meAlign != rOther.meAlign) )
113 return false;
114
115 if( (maSize != rOther.maSize)
116 || (mnOrientation != rOther.mnOrientation)
117 || (mbVertical != rOther.mbVertical) )
118 return false;
119
120 if( (maFamilyName != rOther.maFamilyName)
121 || (maStyleName != rOther.maStyleName) )
122 return false;
123
124 if( (maColor != rOther.maColor)
125 || (maFillColor != rOther.maFillColor) )
126 return false;
127
128 if( (meUnderline != rOther.meUnderline)
129 || (meOverline != rOther.meOverline)
130 || (meStrikeout != rOther.meStrikeout)
131 || (meRelief != rOther.meRelief)
132 || (meEmphasisMark != rOther.meEmphasisMark)
133 || (mbWordLine != rOther.mbWordLine)
134 || (mbOutline != rOther.mbOutline)
135 || (mbShadow != rOther.mbShadow)
136 || (mnKerning != rOther.mnKerning)
137 || (mbTransparent != rOther.mbTransparent) )
138 return false;
139
140 return true;
141 }
142
143 void Impl_Font::AskConfig()
144 {
145 if( mbConfigLookup )
146 return;
147
148 mbConfigLookup = true;
149
150 // prepare the FontSubst configuration lookup
151 const utl::FontSubstConfiguration& rFontSubst = utl::FontSubstConfiguration::get();
152
153 OUString aShortName;
154 OUString aFamilyName;
155 ImplFontAttrs nType = ImplFontAttrs::None;
156 FontWeight eWeight = WEIGHT_DONTKNOW;
157 FontWidth eWidthType = WIDTH_DONTKNOW;
158 OUString aMapName = GetEnglishSearchFontName( maFamilyName );
159
160 utl::FontSubstConfiguration::getMapName( aMapName,
161 aShortName, aFamilyName, eWeight, eWidthType, nType );
162
163 // lookup the font name in the configuration
164 const utl::FontNameAttr* pFontAttr = rFontSubst.getSubstInfo( aMapName );
165
166 // if the direct lookup failed try again with an alias name
167 if ( !pFontAttr && (aShortName != aMapName) )
168 pFontAttr = rFontSubst.getSubstInfo( aShortName );
169
170 if( pFontAttr )
171 {
172 // the font was found in the configuration
173 if( meFamily == FAMILY_DONTKNOW )
174 {
175 if ( pFontAttr->Type & ImplFontAttrs::Serif )
176 meFamily = FAMILY_ROMAN;
177 else if ( pFontAttr->Type & ImplFontAttrs::SansSerif )
178 meFamily = FAMILY_SWISS;
179 else if ( pFontAttr->Type & ImplFontAttrs::Typewriter )
180 meFamily = FAMILY_MODERN;
181 else if ( pFontAttr->Type & ImplFontAttrs::Italic )
182 meFamily = FAMILY_SCRIPT;
183 else if ( pFontAttr->Type & ImplFontAttrs::Decorative )
184 meFamily = FAMILY_DECORATIVE;
185 }
186
187 if( mePitch == PITCH_DONTKNOW )
188 {
189 if ( pFontAttr->Type & ImplFontAttrs::Fixed )
190 mePitch = PITCH_FIXED;
191 }
192 }
193
194 // if some attributes are still unknown then use the FontSubst magic
195 if( meFamily == FAMILY_DONTKNOW )
196 {
197 if( nType & ImplFontAttrs::Serif )
198 meFamily = FAMILY_ROMAN;
199 else if( nType & ImplFontAttrs::SansSerif )
200 meFamily = FAMILY_SWISS;
201 else if( nType & ImplFontAttrs::Typewriter )
202 meFamily = FAMILY_MODERN;
203 else if( nType & ImplFontAttrs::Italic )
204 meFamily = FAMILY_SCRIPT;
205 else if( nType & ImplFontAttrs::Decorative )
206 meFamily = FAMILY_DECORATIVE;
207 }
208
209 if( meWeight == WEIGHT_DONTKNOW )
210 meWeight = eWeight;
211 if( meWidthType == WIDTH_DONTKNOW )
212 meWidthType = eWidthType;
213 }
214
215 void Font::MakeUnique()
216 {
217 // create a copy if others still reference it
218 if ( mpImplFont->mnRefCount != 1 )
219 {
220 if ( mpImplFont->mnRefCount )
221 mpImplFont->mnRefCount--;
222 mpImplFont = new Impl_Font( *mpImplFont );
223 }
224 }
225
226 Font::Font()
227 {
228
229 static Impl_Font aStaticImplFont;
230 // RefCount is zero for static objects
231 aStaticImplFont.mnRefCount = 0;
232 mpImplFont = &aStaticImplFont;
233 }
234
235 Font::Font( const vcl::Font& rFont )
236 {
237 bool bRefIncrementable = rFont.mpImplFont->mnRefCount < ::std::numeric_limits<sal_uInt32>::max();
238 DBG_ASSERT( bRefIncrementable, "Font: RefCount overflow" );
239
240 mpImplFont = rFont.mpImplFont;
241 // do not count static objects (where RefCount is zero)
242 if ( mpImplFont->mnRefCount && bRefIncrementable )
243 mpImplFont->mnRefCount++;
244 }
245
246 Font::Font( const OUString& rFamilyName, const Size& rSize )
247 {
248
249 mpImplFont = new Impl_Font;
250 mpImplFont->maFamilyName = rFamilyName;
251 mpImplFont->maSize = rSize;
252 }
253
254 Font::Font( const OUString& rFamilyName, const OUString& rStyleName, const Size& rSize )
255 {
256
257 mpImplFont = new Impl_Font;
258 mpImplFont->maFamilyName= rFamilyName;
259 mpImplFont->maStyleName = rStyleName;
260 mpImplFont->maSize = rSize;
261 }
262
263 Font::Font( FontFamily eFamily, const Size& rSize )
264 {
265
266 mpImplFont = new Impl_Font;
267 mpImplFont->meFamily = eFamily;
268 mpImplFont->maSize = rSize;
269 }
270
271 Font::~Font()
272 {
273
274 // decrement reference counter and delete if last reference
275 // if the object is not static (Refcounter==0)
276 if ( mpImplFont->mnRefCount )
277 {
278 if ( mpImplFont->mnRefCount == 1 )
279 delete mpImplFont;
280 else
281 mpImplFont->mnRefCount--;
282 }
283 }
284
285 void Font::SetColor( const Color& rColor )
286 {
287
288 if( mpImplFont->maColor != rColor )
289 {
290 MakeUnique();
291 mpImplFont->maColor = rColor;
292 }
293 }
294
295 void Font::SetFillColor( const Color& rColor )
296 {
297
298 MakeUnique();
299 mpImplFont->maFillColor = rColor;
300 if ( rColor.GetTransparency() )
301 mpImplFont->mbTransparent = true;
302 if (GetUnderline() == UNDERLINE_SINGLE ) {
303 SAL_INFO("vcl.gdi", "I'm setting a filling (from Font) of (" << rColor.GetRed() << "," << rColor.GetGreen() << "," << rColor.GetBlue() << ")");
304 }
305 }
306
307 void Font::SetTransparent( bool bTransparent )
308 {
309
310 if( mpImplFont->mbTransparent != bTransparent )
311 {
312 MakeUnique();
313 mpImplFont->mbTransparent = bTransparent;
314 }
315 }
316
317 void Font::SetAlign( FontAlign eAlign )
318 {
319
320 if( mpImplFont->meAlign != eAlign )
321 {
322 MakeUnique();
323 mpImplFont->meAlign = eAlign;
324 }
325 }
326
327 void Font::SetName( const OUString& rFamilyName )
328 {
329
330 MakeUnique();
331 mpImplFont->maFamilyName = rFamilyName;
332 }
333
334 void Font::SetStyleName( const OUString& rStyleName )
335 {
336
337 MakeUnique();
338 mpImplFont->maStyleName = rStyleName;
339 }
340
341 void Font::SetSize( const Size& rSize )
342 {
343
344 if( mpImplFont->maSize != rSize )
345 {
346 MakeUnique();
347 mpImplFont->maSize = rSize;
348 }
349 }
350
351 void Font::SetFamily( FontFamily eFamily )
352 {
353
354 if( mpImplFont->meFamily != eFamily )
355 {
356 MakeUnique();
357 mpImplFont->meFamily = eFamily;
358 }
359 }
360
361 void Font::SetCharSet( rtl_TextEncoding eCharSet )
362 {
363
364 if( mpImplFont->meCharSet != eCharSet )
365 {
366 MakeUnique();
367 mpImplFont->meCharSet = eCharSet;
368 }
369 }
370
371 void Font::SetLanguageTag( const LanguageTag& rLanguageTag )
372 {
373
374 if( mpImplFont->maLanguageTag != rLanguageTag )
375 {
376 MakeUnique();
377 mpImplFont->maLanguageTag = rLanguageTag;
378 }
379 }
380
381 void Font::SetCJKContextLanguageTag( const LanguageTag& rLanguageTag )
382 {
383
384 if( mpImplFont->maCJKLanguageTag != rLanguageTag )
385 {
386 MakeUnique();
387 mpImplFont->maCJKLanguageTag = rLanguageTag;
388 }
389 }
390
391 void Font::SetLanguage( LanguageType eLanguage )
392 {
393
394 if( mpImplFont->maLanguageTag.getLanguageType( false) != eLanguage )
395 {
396 MakeUnique();
397 mpImplFont->maLanguageTag.reset( eLanguage);
398 }
399 }
400
401 void Font::SetCJKContextLanguage( LanguageType eLanguage )
402 {
403
404 if( mpImplFont->maCJKLanguageTag.getLanguageType( false) != eLanguage )
405 {
406 MakeUnique();
407 mpImplFont->maCJKLanguageTag.reset( eLanguage);
408 }
409 }
410
411 void Font::SetPitch( FontPitch ePitch )
412 {
413
414 if( mpImplFont->mePitch != ePitch )
415 {
416 MakeUnique();
417 mpImplFont->mePitch = ePitch;
418 }
419 }
420
421 void Font::SetOrientation( short nOrientation )
422 {
423
424 if( mpImplFont->mnOrientation != nOrientation )
425 {
426 MakeUnique();
427 mpImplFont->mnOrientation = nOrientation;
428 }
429 }
430
431 void Font::SetVertical( bool bVertical )
432 {
433
434 if( mpImplFont->mbVertical != bVertical )
435 {
436 MakeUnique();
437 mpImplFont->mbVertical = bVertical;
438 }
439 }
440
441 void Font::SetKerning( FontKerning nKerning )
442 {
443
444 if( mpImplFont->mnKerning != nKerning )
445 {
446 MakeUnique();
447 mpImplFont->mnKerning = nKerning;
448 }
449 }
450
451 bool Font::IsKerning() const
452 {
453 return bool(mpImplFont->mnKerning & FontKerning::FontSpecific);
454 }
455
456 void Font::SetWeight( FontWeight eWeight )
457 {
458
459 if( mpImplFont->meWeight != eWeight )
460 {
461 MakeUnique();
462 mpImplFont->meWeight = eWeight;
463 }
464 }
465
466 void Font::SetWidthType( FontWidth eWidth )
467 {
468
469 if( mpImplFont->meWidthType != eWidth )
470 {
471 MakeUnique();
472 mpImplFont->meWidthType = eWidth;
473 }
474 }
475
476 void Font::SetItalic( FontItalic eItalic )
477 {
478
479 if( mpImplFont->meItalic != eItalic )
480 {
481 MakeUnique();
482 mpImplFont->meItalic = eItalic;
483 }
484 }
485
486 void Font::SetOutline( bool bOutline )
487 {
488
489 if( mpImplFont->mbOutline != bOutline )
490 {
491 MakeUnique();
492 mpImplFont->mbOutline = bOutline;
493 }
494 }
495
496 void Font::SetShadow( bool bShadow )
497 {
498
499 if( mpImplFont->mbShadow != bShadow )
500 {
501 MakeUnique();
502 mpImplFont->mbShadow = bShadow;
503 }
504 }
505
506 void Font::SetUnderline( FontUnderline eUnderline )
507 {
508
509 if( mpImplFont->meUnderline != eUnderline )
510 {
511 MakeUnique();
512 mpImplFont->meUnderline = eUnderline;
513 }
514 }
515
516 void Font::SetOverline( FontUnderline eOverline )
517 {
518
519 if( mpImplFont->meOverline != eOverline )
520 {
521 MakeUnique();
522 mpImplFont->meOverline = eOverline;
523 }
524 }
525
526 void Font::SetStrikeout( FontStrikeout eStrikeout )
527 {
528
529 if( mpImplFont->meStrikeout != eStrikeout )
530 {
531 MakeUnique();
532 mpImplFont->meStrikeout = eStrikeout;
533 }
534 }
535
536 void Font::SetRelief( FontRelief eRelief )
537 {
538
539 if( mpImplFont->meRelief != eRelief )
540 {
541 MakeUnique();
542 mpImplFont->meRelief = eRelief;
543 }
544 }
545
546 void Font::SetEmphasisMark( FontEmphasisMark eEmphasisMark )
547 {
548
549 if( mpImplFont->meEmphasisMark != eEmphasisMark )
550 {
551 MakeUnique();
552 mpImplFont->meEmphasisMark = eEmphasisMark;
553 }
554 }
555
556 void Font::SetWordLineMode( bool bWordLine )
557 {
558
559 if( mpImplFont->mbWordLine != bWordLine )
560 {
561 MakeUnique();
562 mpImplFont->mbWordLine = bWordLine;
563 }
564 }
565
566 Font& Font::operator=( const vcl::Font& rFont )
567 {
568 bool bRefIncrementable = rFont.mpImplFont->mnRefCount < ::std::numeric_limits<sal_uInt32>::max();
569 DBG_ASSERT( bRefIncrementable, "Font: RefCount overflow" );
570
571 // Increment RefCount first, so that we can reference ourselves
572 // RefCount == 0 for static objects
573 if ( rFont.mpImplFont->mnRefCount && bRefIncrementable )
574 rFont.mpImplFont->mnRefCount++;
575
576 // If it's not static ImplData and if it's the last reference, delete it
577 // else decrement RefCount
578 if ( mpImplFont->mnRefCount )
579 {
580 if ( mpImplFont->mnRefCount == 1 )
581 delete mpImplFont;
582 else
583 mpImplFont->mnRefCount--;
584 }
585
586 mpImplFont = rFont.mpImplFont;
587
588 return *this;
589 }
590
591 bool Font::operator==( const vcl::Font& rFont ) const
592 {
593 return mpImplFont == rFont.mpImplFont || *mpImplFont == *rFont.mpImplFont;
594 }
595
596 void Font::Merge( const vcl::Font& rFont )
597 {
598 if ( !rFont.GetName().isEmpty() )
599 {
600 SetName( rFont.GetName() );
601 SetStyleName( rFont.GetStyleName() );
602 SetCharSet( GetCharSet() );
603 SetLanguageTag( rFont.GetLanguageTag() );
604 SetCJKContextLanguageTag( rFont.GetCJKContextLanguageTag() );
605 // don't use access methods here, might lead to AskConfig(), if DONTKNOW
606 SetFamily( rFont.mpImplFont->meFamily );
607 SetPitch( rFont.mpImplFont->mePitch );
608 }
609
610 // don't use access methods here, might lead to AskConfig(), if DONTKNOW
611 if ( rFont.mpImplFont->meWeight != WEIGHT_DONTKNOW )
612 SetWeight( rFont.GetWeight() );
613 if ( rFont.mpImplFont->meItalic != ITALIC_DONTKNOW )
614 SetItalic( rFont.GetItalic() );
615 if ( rFont.mpImplFont->meWidthType != WIDTH_DONTKNOW )
616 SetWidthType( rFont.GetWidthType() );
617
618 if ( rFont.GetSize().Height() )
619 SetSize( rFont.GetSize() );
620 if ( rFont.GetUnderline() != UNDERLINE_DONTKNOW )
621 {
622 SetUnderline( rFont.GetUnderline() );
623 SetWordLineMode( rFont.IsWordLineMode() );
624 }
625 if ( rFont.GetOverline() != UNDERLINE_DONTKNOW )
626 {
627 SetOverline( rFont.GetOverline() );
628 SetWordLineMode( rFont.IsWordLineMode() );
629 }
630 if ( rFont.GetStrikeout() != STRIKEOUT_DONTKNOW )
631 {
632 SetStrikeout( rFont.GetStrikeout() );
633 SetWordLineMode( rFont.IsWordLineMode() );
634 }
635
636 // Defaults?
637 SetOrientation( rFont.GetOrientation() );
638 SetVertical( rFont.IsVertical() );
639 SetEmphasisMark( rFont.GetEmphasisMark() );
640 SetKerning( rFont.IsKerning() ? FontKerning::FontSpecific : FontKerning::NONE );
641 SetOutline( rFont.IsOutline() );
642 SetShadow( rFont.IsShadow() );
643 SetRelief( rFont.GetRelief() );
644 }
645
646 void Font::GetFontAttributes( ImplFontAttributes& rAttrs ) const
647 {
648 rAttrs.SetFamilyName( mpImplFont->maFamilyName );
649 rAttrs.SetStyleName( mpImplFont->maStyleName );
650 rAttrs.SetFamilyType( mpImplFont->meFamily );
651 rAttrs.SetPitch( mpImplFont->mePitch );
652 rAttrs.SetItalic( mpImplFont->meItalic );
653 rAttrs.SetWeight( mpImplFont->meWeight );
654 rAttrs.SetWidthType( WIDTH_DONTKNOW );
655 rAttrs.SetSymbolFlag( mpImplFont->meCharSet == RTL_TEXTENCODING_SYMBOL );
656 }
657
658 SvStream& ReadImpl_Font( SvStream& rIStm, Impl_Font& rImpl_Font )
659 {
660 VersionCompat aCompat( rIStm, StreamMode::READ );
661 sal_uInt16 nTmp16;
662 bool bTmp;
663 sal_uInt8 nTmp8;
664
665 rImpl_Font.maFamilyName = rIStm.ReadUniOrByteString(rIStm.GetStreamCharSet());
666 rImpl_Font.maStyleName = rIStm.ReadUniOrByteString(rIStm.GetStreamCharSet());
667 ReadPair( rIStm, rImpl_Font.maSize );
668
669 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meCharSet = (rtl_TextEncoding) nTmp16;
670 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meFamily = (FontFamily) nTmp16;
671 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.mePitch = (FontPitch) nTmp16;
672 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meWeight = (FontWeight) nTmp16;
673 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meUnderline = (FontUnderline) nTmp16;
674 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meStrikeout = (FontStrikeout) nTmp16;
675 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meItalic = (FontItalic) nTmp16;
676 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.maLanguageTag.reset( (LanguageType) nTmp16);
677 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meWidthType = (FontWidth) nTmp16;
678
679 rIStm.ReadInt16( rImpl_Font.mnOrientation );
680
681 rIStm.ReadCharAsBool( bTmp ); rImpl_Font.mbWordLine = bTmp;
682 rIStm.ReadCharAsBool( bTmp ); rImpl_Font.mbOutline = bTmp;
683 rIStm.ReadCharAsBool( bTmp ); rImpl_Font.mbShadow = bTmp;
684 rIStm.ReadUChar( nTmp8 ); rImpl_Font.mnKerning = static_cast<FontKerning>(nTmp8);
685
686 if( aCompat.GetVersion() >= 2 )
687 {
688 rIStm.ReadUChar( nTmp8 ); rImpl_Font.meRelief = (FontRelief)nTmp8;
689 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.maCJKLanguageTag.reset( (LanguageType)nTmp16);
690 rIStm.ReadCharAsBool( bTmp ); rImpl_Font.mbVertical = bTmp;
691 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meEmphasisMark = (FontEmphasisMark)nTmp16;
692 }
693 if( aCompat.GetVersion() >= 3 )
694 {
695 rIStm.ReadUInt16( nTmp16 ); rImpl_Font.meOverline = (FontUnderline) nTmp16;
696 }
697 // Relief
698 // CJKContextLanguage
699
700 return rIStm;
701 }
702
703 SvStream& WriteImpl_Font( SvStream& rOStm, const Impl_Font& rImpl_Font )
704 {
705 VersionCompat aCompat( rOStm, StreamMode::WRITE, 3 );
706 rOStm.WriteUniOrByteString( rImpl_Font.maFamilyName, rOStm.GetStreamCharSet() );
707 rOStm.WriteUniOrByteString( rImpl_Font.maStyleName, rOStm.GetStreamCharSet() );
708 WritePair( rOStm, rImpl_Font.maSize );
709
710 rOStm.WriteUInt16( GetStoreCharSet( rImpl_Font.meCharSet ) );
711 rOStm.WriteUInt16( rImpl_Font.meFamily );
712 rOStm.WriteUInt16( rImpl_Font.mePitch );
713 rOStm.WriteUInt16( rImpl_Font.meWeight );
714 rOStm.WriteUInt16( rImpl_Font.meUnderline );
715 rOStm.WriteUInt16( rImpl_Font.meStrikeout );
716 rOStm.WriteUInt16( rImpl_Font.meItalic );
717 rOStm.WriteUInt16( rImpl_Font.maLanguageTag.getLanguageType( false) );
718 rOStm.WriteUInt16( rImpl_Font.meWidthType );
719
720 rOStm.WriteInt16( rImpl_Font.mnOrientation );
721
722 rOStm.WriteBool( rImpl_Font.mbWordLine );
723 rOStm.WriteBool( rImpl_Font.mbOutline );
724 rOStm.WriteBool( rImpl_Font.mbShadow );
725 rOStm.WriteUChar( static_cast<sal_uInt8>(rImpl_Font.mnKerning) );
726
727 // new in version 2
728 rOStm.WriteUChar( rImpl_Font.meRelief );
729 rOStm.WriteUInt16( rImpl_Font.maCJKLanguageTag.getLanguageType( false) );
730 rOStm.WriteBool( rImpl_Font.mbVertical );
731 rOStm.WriteUInt16( rImpl_Font.meEmphasisMark );
732
733 // new in version 3
734 rOStm.WriteUInt16( rImpl_Font.meOverline );
735
736 return rOStm;
737 }
738
739 SvStream& ReadFont( SvStream& rIStm, vcl::Font& rFont )
740 {
741 rFont.MakeUnique();
742 return ReadImpl_Font( rIStm, *rFont.mpImplFont );
743 }
744
745 SvStream& WriteFont( SvStream& rOStm, const vcl::Font& rFont )
746 {
747 return WriteImpl_Font( rOStm, *rFont.mpImplFont );
748 }
749
750 namespace
751 {
752 bool identifyTrueTypeFont( const void* i_pBuffer, sal_uInt32 i_nSize, Font& o_rResult )
753 {
754 bool bResult = false;
755 TrueTypeFont* pTTF = NULL;
756 if( OpenTTFontBuffer( i_pBuffer, i_nSize, 0, &pTTF ) == SF_OK )
757 {
758 TTGlobalFontInfo aInfo;
759 GetTTGlobalFontInfo( pTTF, &aInfo );
760 // most importantly: the family name
761 if( aInfo.ufamily )
762 o_rResult.SetName( aInfo.ufamily );
763 else if( aInfo.family )
764 o_rResult.SetName( OStringToOUString( aInfo.family, RTL_TEXTENCODING_ASCII_US ) );
765 // set weight
766 if( aInfo.weight )
767 {
768 if( aInfo.weight < FW_EXTRALIGHT )
769 o_rResult.SetWeight( WEIGHT_THIN );
770 else if( aInfo.weight < FW_LIGHT )
771 o_rResult.SetWeight( WEIGHT_ULTRALIGHT );
772 else if( aInfo.weight < FW_NORMAL )
773 o_rResult.SetWeight( WEIGHT_LIGHT );
774 else if( aInfo.weight < FW_MEDIUM )
775 o_rResult.SetWeight( WEIGHT_NORMAL );
776 else if( aInfo.weight < FW_SEMIBOLD )
777 o_rResult.SetWeight( WEIGHT_MEDIUM );
778 else if( aInfo.weight < FW_BOLD )
779 o_rResult.SetWeight( WEIGHT_SEMIBOLD );
780 else if( aInfo.weight < FW_EXTRABOLD )
781 o_rResult.SetWeight( WEIGHT_BOLD );
782 else if( aInfo.weight < FW_BLACK )
783 o_rResult.SetWeight( WEIGHT_ULTRABOLD );
784 else
785 o_rResult.SetWeight( WEIGHT_BLACK );
786 }
787 else
788 o_rResult.SetWeight( (aInfo.macStyle & 1) ? WEIGHT_BOLD : WEIGHT_NORMAL );
789 // set width
790 if( aInfo.width )
791 {
792 if( aInfo.width == FWIDTH_ULTRA_CONDENSED )
793 o_rResult.SetWidth( WIDTH_ULTRA_CONDENSED );
794 else if( aInfo.width == FWIDTH_EXTRA_CONDENSED )
795 o_rResult.SetWidth( WIDTH_EXTRA_CONDENSED );
796 else if( aInfo.width == FWIDTH_CONDENSED )
797 o_rResult.SetWidth( WIDTH_CONDENSED );
798 else if( aInfo.width == FWIDTH_SEMI_CONDENSED )
799 o_rResult.SetWidth( WIDTH_SEMI_CONDENSED );
800 else if( aInfo.width == FWIDTH_NORMAL )
801 o_rResult.SetWidth( WIDTH_NORMAL );
802 else if( aInfo.width == FWIDTH_SEMI_EXPANDED )
803 o_rResult.SetWidth( WIDTH_SEMI_EXPANDED );
804 else if( aInfo.width == FWIDTH_EXPANDED )
805 o_rResult.SetWidth( WIDTH_EXPANDED );
806 else if( aInfo.width == FWIDTH_EXTRA_EXPANDED )
807 o_rResult.SetWidth( WIDTH_EXTRA_EXPANDED );
808 else if( aInfo.width >= FWIDTH_ULTRA_EXPANDED )
809 o_rResult.SetWidth( WIDTH_ULTRA_EXPANDED );
810 }
811 // set italic
812 o_rResult.SetItalic( (aInfo.italicAngle != 0) ? ITALIC_NORMAL : ITALIC_NONE );
813
814 // set pitch
815 o_rResult.SetPitch( (aInfo.pitch == 0) ? PITCH_VARIABLE : PITCH_FIXED );
816
817 // set style name
818 if( aInfo.usubfamily )
819 o_rResult.SetStyleName( OUString( aInfo.usubfamily ) );
820 else if( aInfo.subfamily )
821 o_rResult.SetStyleName( OUString::createFromAscii( aInfo.subfamily ) );
822
823 // cleanup
824 CloseTTFont( pTTF );
825 // success
826 bResult = true;
827 }
828 return bResult;
829 }
830
831 struct WeightSearchEntry
832 {
833 const char* string;
834 int string_len;
835 FontWeight weight;
836
837 bool operator<( const WeightSearchEntry& rRight ) const
838 {
839 return rtl_str_compareIgnoreAsciiCase_WithLength( string, string_len, rRight.string, rRight.string_len ) < 0;
840 }
841 }
842 weight_table[] =
843 {
844 { "black", 5, WEIGHT_BLACK },
845 { "bold", 4, WEIGHT_BOLD },
846 { "book", 4, WEIGHT_LIGHT },
847 { "demi", 4, WEIGHT_SEMIBOLD },
848 { "heavy", 5, WEIGHT_BLACK },
849 { "light", 5, WEIGHT_LIGHT },
850 { "medium", 6, WEIGHT_MEDIUM },
851 { "regular", 7, WEIGHT_NORMAL },
852 { "super", 5, WEIGHT_ULTRABOLD },
853 { "thin", 4, WEIGHT_THIN }
854 };
855
856 bool identifyType1Font( const char* i_pBuffer, sal_uInt32 i_nSize, Font& o_rResult )
857 {
858 bool bResult = false;
859 // might be a type1, find eexec
860 const char* pStream = i_pBuffer;
861 const char* pExec = "eexec";
862 const char* pExecPos = std::search( pStream, pStream+i_nSize, pExec, pExec+5 );
863 if( pExecPos != pStream+i_nSize)
864 {
865 // find /FamilyName entry
866 static const char* pFam = "/FamilyName";
867 const char* pFamPos = std::search( pStream, pExecPos, pFam, pFam+11 );
868 if( pFamPos != pExecPos )
869 {
870 // extract the string value behind /FamilyName
871 const char* pOpen = pFamPos+11;
872 while( pOpen < pExecPos && *pOpen != '(' )
873 pOpen++;
874 const char* pClose = pOpen;
875 while( pClose < pExecPos && *pClose != ')' )
876 pClose++;
877 if( pClose - pOpen > 1 )
878 {
879 o_rResult.SetName( OStringToOUString( OString( pOpen+1, pClose-pOpen-1 ), RTL_TEXTENCODING_ASCII_US ) );
880 }
881 }
882
883 // parse /ItalicAngle
884 static const char* pItalic = "/ItalicAngle";
885 const char* pItalicPos = std::search( pStream, pExecPos, pItalic, pItalic+12 );
886 if( pItalicPos != pExecPos )
887 {
888 sal_Int32 nItalic = rtl_str_toInt32( pItalicPos+12, 10 );
889 o_rResult.SetItalic( (nItalic != 0) ? ITALIC_NORMAL : ITALIC_NONE );
890 }
891
892 // parse /Weight
893 static const char* pWeight = "/Weight";
894 const char* pWeightPos = std::search( pStream, pExecPos, pWeight, pWeight+7 );
895 if( pWeightPos != pExecPos )
896 {
897 // extract the string value behind /Weight
898 const char* pOpen = pWeightPos+7;
899 while( pOpen < pExecPos && *pOpen != '(' )
900 pOpen++;
901 const char* pClose = pOpen;
902 while( pClose < pExecPos && *pClose != ')' )
903 pClose++;
904 if( pClose - pOpen > 1 )
905 {
906 WeightSearchEntry aEnt;
907 aEnt.string = pOpen+1;
908 aEnt.string_len = (pClose-pOpen)-1;
909 aEnt.weight = WEIGHT_NORMAL;
910 const int nEnt = SAL_N_ELEMENTS( weight_table );
911 WeightSearchEntry* pFound = std::lower_bound( weight_table, weight_table+nEnt, aEnt );
912 if( pFound != (weight_table+nEnt) )
913 o_rResult.SetWeight( pFound->weight );
914 }
915 }
916
917 // parse isFixedPitch
918 static const char* pFixed = "/isFixedPitch";
919 const char* pFixedPos = std::search( pStream, pExecPos, pFixed, pFixed+13 );
920 if( pFixedPos != pExecPos )
921 {
922 // skip whitespace
923 while( pFixedPos < pExecPos-4 &&
924 ( *pFixedPos == ' ' ||
925 *pFixedPos == '\t' ||
926 *pFixedPos == '\r' ||
927 *pFixedPos == '\n' ) )
928 {
929 pFixedPos++;
930 }
931 // find "true" value
932 if( rtl_str_compareIgnoreAsciiCase_WithLength( pFixedPos, 4, "true", 4 ) == 0 )
933 o_rResult.SetPitch( PITCH_FIXED );
934 else
935 o_rResult.SetPitch( PITCH_VARIABLE );
936 }
937 }
938 return bResult;
939 }
940 }
941
942 Font Font::identifyFont( const void* i_pBuffer, sal_uInt32 i_nSize )
943 {
944 Font aResult;
945 if( ! identifyTrueTypeFont( i_pBuffer, i_nSize, aResult ) )
946 {
947 const char* pStream = static_cast<const char*>(i_pBuffer);
948 if( pStream && i_nSize > 100 &&
949 *pStream == '%' && pStream[1] == '!' )
950 {
951 identifyType1Font( pStream, i_nSize, aResult );
952 }
953 }
954
955 return aResult;
956 }
957
958 // The inlines from the font.hxx header are now instantiated for pImpl-ification
959 const Color& Font::GetColor() const { return mpImplFont->maColor; }
960
961 const Color& Font::GetFillColor() const { return mpImplFont->maFillColor; }
962
963 bool Font::IsTransparent() const { return mpImplFont->mbTransparent; }
964
965 FontAlign Font::GetAlign() const { return mpImplFont->meAlign; }
966
967 const OUString& Font::GetName() const { return mpImplFont->maFamilyName; }
968
969 const OUString& Font::GetStyleName() const { return mpImplFont->maStyleName; }
970
971 const Size& Font::GetSize() const { return mpImplFont->maSize; }
972
973 void Font::SetHeight( long nHeight ) { SetSize( Size( mpImplFont->maSize.Width(), nHeight ) ); }
974
975 long Font::GetHeight() const { return mpImplFont->maSize.Height(); }
976
977 void Font::SetWidth( long nWidth ) { SetSize( Size( nWidth, mpImplFont->maSize.Height() ) ); }
978
979 long Font::GetWidth() const { return mpImplFont->maSize.Width(); }
980
981 rtl_TextEncoding Font::GetCharSet() const { return mpImplFont->meCharSet; }
982
983 const LanguageTag& Font::GetLanguageTag() const { return mpImplFont->maLanguageTag; }
984
985 const LanguageTag& Font::GetCJKContextLanguageTag() const { return mpImplFont->maCJKLanguageTag; }
986
987 LanguageType Font::GetLanguage() const { return mpImplFont->maLanguageTag.getLanguageType( false); }
988
989 LanguageType Font::GetCJKContextLanguage() const { return mpImplFont->maCJKLanguageTag.getLanguageType( false); }
990
991 short Font::GetOrientation() const { return mpImplFont->mnOrientation; }
992
993 bool Font::IsVertical() const { return mpImplFont->mbVertical; }
994
995 FontKerning Font::GetKerning() const { return mpImplFont->mnKerning; }
996
997 FontPitch Font::GetPitch() const { return mpImplFont->GetPitch(); }
998
999 FontWeight Font::GetWeight() const { return mpImplFont->GetWeight(); }
1000
1001 FontWidth Font::GetWidthType() const { return mpImplFont->GetWidthType(); }
1002
1003 FontItalic Font::GetItalic() const { return mpImplFont->GetItalic(); }
1004
1005 FontFamily Font::GetFamily() const { return mpImplFont->GetFamily(); }
1006
1007 bool Font::IsOutline() const { return mpImplFont->mbOutline; }
1008
1009 bool Font::IsShadow() const { return mpImplFont->mbShadow; }
1010
1011 FontRelief Font::GetRelief() const { return mpImplFont->meRelief; }
1012
1013 FontUnderline Font::GetUnderline() const { return mpImplFont->meUnderline; }
1014
1015 FontUnderline Font::GetOverline() const { return mpImplFont->meOverline; }
1016
1017 FontStrikeout Font::GetStrikeout() const { return mpImplFont->meStrikeout; }
1018
1019 FontEmphasisMark Font::GetEmphasisMark() const { return mpImplFont->meEmphasisMark; }
1020
1021 bool Font::IsWordLineMode() const { return mpImplFont->mbWordLine; }
1022
1023 bool Font::IsSameInstance( const vcl::Font& rFont ) const { return (mpImplFont == rFont.mpImplFont); }
1024
1025 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE