vcl/source/gdi/font.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: font.cxx,v $
  10  * $Revision: 1.19.134.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include "sft.hxx"
  35
  36 #include "tools/stream.hxx"
  37 #include "tools/vcompat.hxx"
  38 #include "tools/debug.hxx"
  39 #include "vcl/font.hxx"
  40 #include "vcl/impfont.hxx"
  41 #include "vcl/fontcfg.hxx"
  42 #include "vcl/outdev.h" // just for ImplGetEnglishSearchFontName! TODO: move it
  43
  44 #include <algorithm>
  45
  46 using namespace vcl;
  47
  48 // =======================================================================
  49
  50 DBG_NAME( Font )
  51
  52 // -----------------------------------------------------------------------
  53
  54 Impl_Font::Impl_Font() :
  55     maColor( COL_TRANSPARENT ),
  56     maFillColor( COL_TRANSPARENT )
  57 {
  58     mnRefCount                  = 1;
  59     meCharSet                   = RTL_TEXTENCODING_DONTKNOW;
  60     meLanguage                  = LANGUAGE_DONTKNOW;
  61     meCJKLanguage               = LANGUAGE_DONTKNOW;
  62     meFamily                    = FAMILY_DONTKNOW;
  63     mePitch                     = PITCH_DONTKNOW;
  64     meAlign                     = ALIGN_TOP;
  65     meWeight                    = WEIGHT_DONTKNOW;
  66     meWidthType                 = WIDTH_DONTKNOW;
  67     meItalic                    = ITALIC_NONE;
  68     meUnderline                 = UNDERLINE_NONE;
  69     meOverline                  = UNDERLINE_NONE;
  70     meStrikeout                 = STRIKEOUT_NONE;
  71     meRelief                    = RELIEF_NONE;
  72     meEmphasisMark              = EMPHASISMARK_NONE;
  73     mnOrientation               = 0;
  74     mnKerning                   = 0;
  75     mbWordLine                  = false;
  76     mbOutline                   = false;
  77     mbShadow                    = false;
  78     mbVertical                  = false;
  79     mbTransparent               = true;
  80     mbConfigLookup              = false;
  81 }
  82
  83 // -----------------------------------------------------------------------
  84
  85 Impl_Font::Impl_Font( const Impl_Font& rImplFont )
  86 :   maFamilyName( rImplFont.maFamilyName ),
  87     maStyleName( rImplFont.maStyleName ),
  88     maSize( rImplFont.maSize ),
  89     maColor( rImplFont.maColor ),
  90     maFillColor( rImplFont.maFillColor )
  91 {
  92     mnRefCount                  = 1;
  93     meCharSet                   = rImplFont.meCharSet;
  94     meLanguage                  = rImplFont.meLanguage;
  95     meCJKLanguage               = rImplFont.meCJKLanguage;
  96     meFamily                    = rImplFont.meFamily;
  97     mePitch                     = rImplFont.mePitch;
  98     meAlign                     = rImplFont.meAlign;
  99     meWeight                    = rImplFont.meWeight;
 100     meWidthType                 = rImplFont.meWidthType;
 101     meItalic                    = rImplFont.meItalic;
 102     meUnderline                 = rImplFont.meUnderline;
 103     meOverline                  = rImplFont.meOverline;
 104     meStrikeout                 = rImplFont.meStrikeout;
 105     meRelief                    = rImplFont.meRelief;
 106     meEmphasisMark              = rImplFont.meEmphasisMark;
 107     mnOrientation               = rImplFont.mnOrientation;
 108     mnKerning                   = rImplFont.mnKerning;
 109     mbWordLine                  = rImplFont.mbWordLine;
 110     mbOutline                   = rImplFont.mbOutline;
 111     mbShadow                    = rImplFont.mbShadow;
 112     mbVertical                  = rImplFont.mbVertical;
 113     mbTransparent               = rImplFont.mbTransparent;
 114     mbConfigLookup              = rImplFont.mbConfigLookup;
 115 }
 116
 117 // -----------------------------------------------------------------------
 118
 119 bool Impl_Font::operator==( const Impl_Font& rOther ) const
 120 {
 121     // equality tests split up for easier debugging
 122     if( (meWeight   != rOther.meWeight)
 123     ||  (meItalic   != rOther.meItalic)
 124     ||  (meFamily   != rOther.meFamily)
 125     ||  (mePitch    != rOther.mePitch) )
 126         return false;
 127
 128     if( (meCharSet     != rOther.meCharSet)
 129     ||  (meLanguage    != rOther.meLanguage)
 130     ||  (meCJKLanguage != rOther.meCJKLanguage)
 131     ||  (meAlign       != rOther.meAlign) )
 132         return false;
 133
 134     if( (maSize         != rOther.maSize)
 135     ||  (mnOrientation  != rOther.mnOrientation)
 136     ||  (mbVertical     != rOther.mbVertical) )
 137         return false;
 138
 139     if( (maFamilyName   != rOther.maFamilyName)
 140     ||  (maStyleName    != rOther.maStyleName) )
 141         return false;
 142
 143     if( (maColor        != rOther.maColor)
 144     ||  (maFillColor    != rOther.maFillColor) )
 145         return false;
 146
 147     if( (meUnderline    != rOther.meUnderline)
 148     ||  (meOverline     != rOther.meOverline)
 149     ||  (meStrikeout    != rOther.meStrikeout)
 150     ||  (meRelief       != rOther.meRelief)
 151     ||  (meEmphasisMark != rOther.meEmphasisMark)
 152     ||  (mbWordLine     != rOther.mbWordLine)
 153     ||  (mbOutline      != rOther.mbOutline)
 154     ||  (mbShadow       != rOther.mbShadow)
 155     ||  (mnKerning      != rOther.mnKerning)
 156     ||  (mbTransparent  != rOther.mbTransparent) )
 157         return false;
 158
 159     return true;
 160 }
 161
 162 // -----------------------------------------------------------------------
 163
 164 void Impl_Font::AskConfig()
 165 {
 166     if( mbConfigLookup )
 167         return;
 168
 169     mbConfigLookup = true;
 170
 171     // prepare the FontSubst configuration lookup
 172     const vcl::FontSubstConfiguration* pFontSubst = vcl::FontSubstConfiguration::get();
 173
 174     String      aShortName;
 175     String      aFamilyName;
 176     ULONG       nType = 0;
 177     FontWeight  eWeight = WEIGHT_DONTKNOW;
 178     FontWidth   eWidthType = WIDTH_DONTKNOW;
 179     String      aMapName = maFamilyName;
 180     ImplGetEnglishSearchFontName( aMapName );
 181     vcl::FontSubstConfiguration::getMapName( aMapName,
 182         aShortName, aFamilyName, eWeight, eWidthType, nType );
 183
 184     // lookup the font name in the configuration
 185     const vcl::FontNameAttr* pFontAttr = pFontSubst->getSubstInfo( aMapName );
 186
 187     // if the direct lookup failed try again with an alias name
 188     if ( !pFontAttr && (aShortName != aMapName) )
 189         pFontAttr = pFontSubst->getSubstInfo( aShortName );
 190
 191     if( pFontAttr )
 192     {
 193         // the font was found in the configuration
 194         if( meFamily == FAMILY_DONTKNOW )
 195         {
 196             if ( pFontAttr->Type & IMPL_FONT_ATTR_SERIF )
 197                 meFamily = FAMILY_ROMAN;
 198             else if ( pFontAttr->Type & IMPL_FONT_ATTR_SANSSERIF )
 199                 meFamily = FAMILY_SWISS;
 200             else if ( pFontAttr->Type & IMPL_FONT_ATTR_TYPEWRITER )
 201                 meFamily = FAMILY_MODERN;
 202             else if ( pFontAttr->Type & IMPL_FONT_ATTR_ITALIC )
 203                 meFamily = FAMILY_SCRIPT;
 204             else if ( pFontAttr->Type & IMPL_FONT_ATTR_DECORATIVE )
 205                 meFamily = FAMILY_DECORATIVE;
 206         }
 207
 208         if( mePitch == PITCH_DONTKNOW )
 209         {
 210             if ( pFontAttr->Type & IMPL_FONT_ATTR_FIXED )
 211                 mePitch = PITCH_FIXED;
 212         }
 213     }
 214
 215     // if some attributes are still unknown then use the FontSubst magic
 216     if( meFamily == FAMILY_DONTKNOW )
 217     {
 218         if( nType & IMPL_FONT_ATTR_SERIF )
 219             meFamily = FAMILY_ROMAN;
 220         else if( nType & IMPL_FONT_ATTR_SANSSERIF )
 221             meFamily = FAMILY_SWISS;
 222         else if( nType & IMPL_FONT_ATTR_TYPEWRITER )
 223             meFamily = FAMILY_MODERN;
 224         else if( nType & IMPL_FONT_ATTR_ITALIC )
 225             meFamily = FAMILY_SCRIPT;
 226         else if( nType & IMPL_FONT_ATTR_DECORATIVE )
 227             meFamily = FAMILY_DECORATIVE;
 228     }
 229
 230     if( meWeight == WEIGHT_DONTKNOW )
 231         meWeight = eWeight;
 232     if( meWidthType == WIDTH_DONTKNOW )
 233         meWidthType = eWidthType;
 234 }
 235
 236 // =======================================================================
 237
 238 void Font::MakeUnique()
 239 {
 240     // create a copy if others still reference it
 241     if ( mpImplFont->mnRefCount != 1 )
 242     {
 243         if ( mpImplFont->mnRefCount )
 244             mpImplFont->mnRefCount--;
 245         mpImplFont = new Impl_Font( *mpImplFont );
 246     }
 247 }
 248
 249 // -----------------------------------------------------------------------
 250
 251 Font::Font()
 252 {
 253     DBG_CTOR( Font, NULL );
 254
 255     static Impl_Font aStaticImplFont;
 256     // RefCount is zero for static objects
 257     aStaticImplFont.mnRefCount = 0;
 258     mpImplFont = &aStaticImplFont;
 259 }
 260
 261 // -----------------------------------------------------------------------
 262
 263 Font::Font( const Font& rFont )
 264 {
 265     DBG_CTOR( Font, NULL );
 266     DBG_CHKOBJ( &rFont, Font, NULL );
 267     DBG_ASSERT( rFont.mpImplFont->mnRefCount < 0xFFFE, "Font: RefCount overflow" );
 268
 269     mpImplFont = rFont.mpImplFont;
 270     // do not count static objects (where RefCount is zero)
 271     if ( mpImplFont->mnRefCount )
 272         mpImplFont->mnRefCount++;
 273 }
 274
 275 // -----------------------------------------------------------------------
 276
 277 Font::Font( const String& rFamilyName, const Size& rSize )
 278 {
 279     DBG_CTOR( Font, NULL );
 280
 281     mpImplFont                          = new Impl_Font;
 282     mpImplFont->maFamilyName= rFamilyName;
 283     mpImplFont->maSize          = rSize;
 284 }
 285
 286 // -----------------------------------------------------------------------
 287
 288 Font::Font( const String& rFamilyName, const String& rStyleName, const Size& rSize )
 289 {
 290     DBG_CTOR( Font, NULL );
 291
 292     mpImplFont                          = new Impl_Font;
 293     mpImplFont->maFamilyName= rFamilyName;
 294     mpImplFont->maStyleName = rStyleName;
 295     mpImplFont->maSize          = rSize;
 296 }
 297
 298 // -----------------------------------------------------------------------
 299
 300 Font::Font( FontFamily eFamily, const Size& rSize )
 301 {
 302     DBG_CTOR( Font, NULL );
 303
 304     mpImplFont                          = new Impl_Font;
 305     mpImplFont->meFamily        = eFamily;
 306     mpImplFont->maSize          = rSize;
 307 }
 308
 309 // -----------------------------------------------------------------------
 310
 311 Font::~Font()
 312 {
 313     DBG_DTOR( Font, NULL );
 314
 315     // decrement reference counter and delete if last reference
 316     // if the object is not static (Refcounter==0)
 317     if ( mpImplFont->mnRefCount )
 318     {
 319         if ( mpImplFont->mnRefCount == 1 )
 320             delete mpImplFont;
 321         else
 322             mpImplFont->mnRefCount--;
 323     }
 324 }
 325
 326 // -----------------------------------------------------------------------
 327
 328 void Font::SetColor( const Color& rColor )
 329 {
 330     DBG_CHKTHIS( Font, NULL );
 331
 332     if( mpImplFont->maColor != rColor )
 333     {
 334         MakeUnique();
 335         mpImplFont->maColor = rColor;
 336     }
 337 }
 338
 339 // -----------------------------------------------------------------------
 340
 341 void Font::SetFillColor( const Color& rColor )
 342 {
 343     DBG_CHKTHIS( Font, NULL );
 344
 345     MakeUnique();
 346     mpImplFont->maFillColor = rColor;
 347     if ( rColor.GetTransparency() )
 348         mpImplFont->mbTransparent = true;
 349 }
 350
 351 // -----------------------------------------------------------------------
 352
 353 void Font::SetTransparent( BOOL bTransparent )
 354 {
 355     DBG_CHKTHIS( Font, NULL );
 356
 357     if( mpImplFont->mbTransparent != bTransparent )
 358     {
 359         MakeUnique();
 360         mpImplFont->mbTransparent = bTransparent;
 361     }
 362 }
 363
 364 // -----------------------------------------------------------------------
 365
 366 void Font::SetAlign( FontAlign eAlign )
 367 {
 368     DBG_CHKTHIS( Font, NULL );
 369
 370     if( mpImplFont->meAlign != eAlign )
 371     {
 372         MakeUnique();
 373         mpImplFont->meAlign = eAlign;
 374     }
 375 }
 376
 377 // -----------------------------------------------------------------------
 378
 379 void Font::SetName( const String& rFamilyName )
 380 {
 381     DBG_CHKTHIS( Font, NULL );
 382
 383     MakeUnique();
 384     mpImplFont->maFamilyName = rFamilyName;
 385 }
 386
 387 // -----------------------------------------------------------------------
 388
 389 void Font::SetStyleName( const String& rStyleName )
 390 {
 391     DBG_CHKTHIS( Font, NULL );
 392
 393     MakeUnique();
 394     mpImplFont->maStyleName = rStyleName;
 395 }
 396
 397 // -----------------------------------------------------------------------
 398
 399 void Font::SetSize( const Size& rSize )
 400 {
 401     DBG_CHKTHIS( Font, NULL );
 402
 403     if( mpImplFont->maSize != rSize )
 404     {
 405         MakeUnique();
 406         mpImplFont->maSize = rSize;
 407     }
 408 }
 409
 410 // -----------------------------------------------------------------------
 411
 412 void Font::SetFamily( FontFamily eFamily )
 413 {
 414     DBG_CHKTHIS( Font, NULL );
 415
 416     if( mpImplFont->meFamily != eFamily )
 417     {
 418         MakeUnique();
 419         mpImplFont->meFamily = eFamily;
 420     }
 421 }
 422
 423 // -----------------------------------------------------------------------
 424
 425 void Font::SetCharSet( CharSet eCharSet )
 426 {
 427     DBG_CHKTHIS( Font, NULL );
 428
 429     if( mpImplFont->meCharSet != eCharSet )
 430     {
 431         MakeUnique();
 432         mpImplFont->meCharSet = eCharSet;
 433     }
 434 }
 435
 436 // -----------------------------------------------------------------------
 437
 438 void Font::SetLanguage( LanguageType eLanguage )
 439 {
 440     DBG_CHKTHIS( Font, NULL );
 441
 442     if( mpImplFont->meLanguage != eLanguage )
 443     {
 444         MakeUnique();
 445         mpImplFont->meLanguage = eLanguage;
 446     }
 447 }
 448
 449 // -----------------------------------------------------------------------
 450
 451 void Font::SetCJKContextLanguage( LanguageType eLanguage )
 452 {
 453     DBG_CHKTHIS( Font, NULL );
 454
 455     if( mpImplFont->meCJKLanguage != eLanguage )
 456     {
 457         MakeUnique();
 458         mpImplFont->meCJKLanguage = eLanguage;
 459     }
 460 }
 461
 462 // -----------------------------------------------------------------------
 463
 464 void Font::SetPitch( FontPitch ePitch )
 465 {
 466     DBG_CHKTHIS( Font, NULL );
 467
 468     if( mpImplFont->mePitch != ePitch )
 469     {
 470         MakeUnique();
 471         mpImplFont->mePitch = ePitch;
 472     }
 473 }
 474
 475 // -----------------------------------------------------------------------
 476
 477 void Font::SetOrientation( short nOrientation )
 478 {
 479     DBG_CHKTHIS( Font, NULL );
 480
 481     if( mpImplFont->mnOrientation != nOrientation )
 482     {
 483         MakeUnique();
 484         mpImplFont->mnOrientation = nOrientation;
 485     }
 486 }
 487
 488 // -----------------------------------------------------------------------
 489
 490 void Font::SetVertical( BOOL bVertical )
 491 {
 492     DBG_CHKTHIS( Font, NULL );
 493
 494     if( mpImplFont->mbVertical != bVertical )
 495     {
 496         MakeUnique();
 497         mpImplFont->mbVertical = bVertical;
 498     }
 499 }
 500
 501 // -----------------------------------------------------------------------
 502
 503 void Font::SetKerning( FontKerning nKerning )
 504 {
 505     DBG_CHKTHIS( Font, NULL );
 506
 507     if( mpImplFont->mnKerning != nKerning )
 508     {
 509         MakeUnique();
 510         mpImplFont->mnKerning = nKerning;
 511     }
 512 }
 513
 514 // -----------------------------------------------------------------------
 515
 516 BOOL Font::IsKerning() const
 517 {
 518     return (mpImplFont->mnKerning & KERNING_FONTSPECIFIC) != 0;
 519 }
 520
 521 // -----------------------------------------------------------------------
 522
 523 void Font::SetWeight( FontWeight eWeight )
 524 {
 525     DBG_CHKTHIS( Font, NULL );
 526
 527     if( mpImplFont->meWeight != eWeight )
 528     {
 529         MakeUnique();
 530         mpImplFont->meWeight = eWeight;
 531     }
 532 }
 533
 534 // -----------------------------------------------------------------------
 535
 536 void Font::SetWidthType( FontWidth eWidth )
 537 {
 538     DBG_CHKTHIS( Font, NULL );
 539
 540     if( mpImplFont->meWidthType != eWidth )
 541     {
 542         MakeUnique();
 543         mpImplFont->meWidthType = eWidth;
 544     }
 545 }
 546
 547 // -----------------------------------------------------------------------
 548
 549 void Font::SetItalic( FontItalic eItalic )
 550 {
 551     DBG_CHKTHIS( Font, NULL );
 552
 553     if( mpImplFont->meItalic != eItalic )
 554     {
 555         MakeUnique();
 556         mpImplFont->meItalic = eItalic;
 557     }
 558 }
 559
 560 // -----------------------------------------------------------------------
 561
 562 void Font::SetOutline( BOOL bOutline )
 563 {
 564     DBG_CHKTHIS( Font, NULL );
 565
 566     if( mpImplFont->mbOutline != bOutline )
 567     {
 568         MakeUnique();
 569         mpImplFont->mbOutline = bOutline;
 570     }
 571 }
 572
 573 // -----------------------------------------------------------------------
 574
 575 void Font::SetShadow( BOOL bShadow )
 576 {
 577     DBG_CHKTHIS( Font, NULL );
 578
 579     if( mpImplFont->mbShadow != bShadow )
 580     {
 581         MakeUnique();
 582         mpImplFont->mbShadow = bShadow;
 583     }
 584 }
 585
 586 // -----------------------------------------------------------------------
 587
 588 void Font::SetUnderline( FontUnderline eUnderline )
 589 {
 590     DBG_CHKTHIS( Font, NULL );
 591
 592     if( mpImplFont->meUnderline != eUnderline )
 593     {
 594         MakeUnique();
 595         mpImplFont->meUnderline = eUnderline;
 596     }
 597 }
 598
 599 // -----------------------------------------------------------------------
 600
 601 void Font::SetOverline( FontUnderline eOverline )
 602 {
 603     DBG_CHKTHIS( Font, NULL );
 604
 605     if( mpImplFont->meOverline != eOverline )
 606     {
 607         MakeUnique();
 608         mpImplFont->meOverline = eOverline;
 609     }
 610 }
 611
 612 // -----------------------------------------------------------------------
 613
 614 void Font::SetStrikeout( FontStrikeout eStrikeout )
 615 {
 616     DBG_CHKTHIS( Font, NULL );
 617
 618     if( mpImplFont->meStrikeout != eStrikeout )
 619     {
 620         MakeUnique();
 621         mpImplFont->meStrikeout = eStrikeout;
 622     }
 623 }
 624
 625 // -----------------------------------------------------------------------
 626
 627 void Font::SetRelief( FontRelief eRelief )
 628 {
 629     DBG_CHKTHIS( Font, NULL );
 630
 631     if( mpImplFont->meRelief != eRelief )
 632     {
 633         MakeUnique();
 634         mpImplFont->meRelief = eRelief;
 635     }
 636 }
 637
 638 // -----------------------------------------------------------------------
 639
 640 void Font::SetEmphasisMark( FontEmphasisMark eEmphasisMark )
 641 {
 642     DBG_CHKTHIS( Font, NULL );
 643
 644     if( mpImplFont->meEmphasisMark != eEmphasisMark )
 645     {
 646         MakeUnique();
 647         mpImplFont->meEmphasisMark = eEmphasisMark;
 648     }
 649 }
 650
 651 // -----------------------------------------------------------------------
 652
 653 void Font::SetWordLineMode( BOOL bWordLine )
 654 {
 655     DBG_CHKTHIS( Font, NULL );
 656
 657     if( mpImplFont->mbWordLine != bWordLine )
 658     {
 659         MakeUnique();
 660         mpImplFont->mbWordLine = bWordLine;
 661     }
 662 }
 663
 664 // -----------------------------------------------------------------------
 665
 666 Font& Font::operator=( const Font& rFont )
 667 {
 668     DBG_CHKTHIS( Font, NULL );
 669     DBG_CHKOBJ( &rFont, Font, NULL );
 670     DBG_ASSERT( rFont.mpImplFont->mnRefCount < 0xFFFE, "Font: RefCount overflow" );
 671
 672     // Zuerst Referenzcounter erhoehen, damit man sich selbst zuweisen kann
 673     // RefCount == 0 fuer statische Objekte
 674     if ( rFont.mpImplFont->mnRefCount )
 675         rFont.mpImplFont->mnRefCount++;
 676
 677     // Wenn es keine statischen ImplDaten sind, dann loeschen, wenn es
 678     // die letzte Referenz ist, sonst Referenzcounter decrementieren
 679     if ( mpImplFont->mnRefCount )
 680     {
 681         if ( mpImplFont->mnRefCount == 1 )
 682             delete mpImplFont;
 683         else
 684             mpImplFont->mnRefCount--;
 685     }
 686
 687     mpImplFont = rFont.mpImplFont;
 688
 689     return *this;
 690 }
 691
 692 // -----------------------------------------------------------------------
 693
 694 BOOL Font::operator==( const Font& rFont ) const
 695 {
 696     DBG_CHKTHIS( Font, NULL );
 697     DBG_CHKOBJ( &rFont, Font, NULL );
 698
 699     if( mpImplFont == rFont.mpImplFont )
 700         return TRUE;
 701     if( *mpImplFont == *rFont.mpImplFont )
 702         return TRUE;
 703
 704     return FALSE;
 705 }
 706
 707 // -----------------------------------------------------------------------
 708
 709 void Font::Merge( const Font& rFont )
 710 {
 711     if ( rFont.GetName().Len() )
 712     {
 713         SetName( rFont.GetName() );
 714         SetStyleName( rFont.GetStyleName() );
 715         SetCharSet( GetCharSet() );
 716         SetLanguage( rFont.GetLanguage() );
 717         SetCJKContextLanguage( rFont.GetCJKContextLanguage() );
 718         // don't use access methods here, might lead to AskConfig(), if DONTKNOW
 719         SetFamily( rFont.mpImplFont->meFamily );
 720         SetPitch( rFont.mpImplFont->mePitch );
 721     }
 722
 723     // don't use access methods here, might lead to AskConfig(), if DONTKNOW
 724     if ( rFont.mpImplFont->meWeight != WEIGHT_DONTKNOW )
 725         SetWeight( rFont.GetWeight() );
 726     if ( rFont.mpImplFont->meItalic != ITALIC_DONTKNOW )
 727         SetItalic( rFont.GetItalic() );
 728     if ( rFont.mpImplFont->meWidthType != WIDTH_DONTKNOW )
 729         SetWidthType( rFont.GetWidthType() );
 730
 731
 732     if ( rFont.GetSize().Height() )
 733         SetSize( rFont.GetSize() );
 734     if ( rFont.GetUnderline() != UNDERLINE_DONTKNOW )
 735     {
 736         SetUnderline( rFont.GetUnderline() );
 737         SetWordLineMode( rFont.IsWordLineMode() );
 738     }
 739     if ( rFont.GetOverline() != UNDERLINE_DONTKNOW )
 740     {
 741         SetOverline( rFont.GetOverline() );
 742         SetWordLineMode( rFont.IsWordLineMode() );
 743     }
 744     if ( rFont.GetStrikeout() != STRIKEOUT_DONTKNOW )
 745     {
 746         SetStrikeout( rFont.GetStrikeout() );
 747         SetWordLineMode( rFont.IsWordLineMode() );
 748     }
 749
 750     // Defaults?
 751     SetOrientation( rFont.GetOrientation() );
 752     SetVertical( rFont.IsVertical() );
 753     SetEmphasisMark( rFont.GetEmphasisMark() );
 754     SetKerning( rFont.IsKerning() );
 755     SetOutline( rFont.IsOutline() );
 756     SetShadow( rFont.IsShadow() );
 757     SetRelief( rFont.GetRelief() );
 758 }
 759
 760 void Font::GetFontAttributes( ImplFontAttributes& rAttrs ) const
 761 {
 762     // #i56788# Use members directly, don't risc config access.
 763     rAttrs.maName = mpImplFont->maFamilyName;
 764     rAttrs.maStyleName = mpImplFont->maStyleName;
 765     rAttrs.meFamily = mpImplFont->meFamily;
 766     rAttrs.mePitch = mpImplFont->mePitch;
 767     rAttrs.meItalic = mpImplFont->meItalic;
 768     rAttrs.meWeight = mpImplFont->meWeight;
 769     rAttrs.meWidthType = WIDTH_DONTKNOW;
 770     rAttrs.mbSymbolFlag= (mpImplFont->meCharSet == RTL_TEXTENCODING_SYMBOL);
 771 }
 772
 773
 774 // -----------------------------------------------------------------------
 775
 776 SvStream& operator>>( SvStream& rIStm, Impl_Font& rImpl_Font )
 777 {
 778     VersionCompat       aCompat( rIStm, STREAM_READ );
 779     UINT16                      nTmp16;
 780     BOOL                        bTmp;
 781     BYTE                        nTmp8;
 782
 783     rIStm.ReadByteString( rImpl_Font.maFamilyName, rIStm.GetStreamCharSet() );
 784     rIStm.ReadByteString( rImpl_Font.maStyleName, rIStm.GetStreamCharSet() );
 785     rIStm >> rImpl_Font.maSize;
 786
 787     rIStm >> nTmp16; rImpl_Font.meCharSet = (rtl_TextEncoding) nTmp16;
 788     rIStm >> nTmp16; rImpl_Font.meFamily = (FontFamily) nTmp16;
 789     rIStm >> nTmp16; rImpl_Font.mePitch = (FontPitch) nTmp16;
 790     rIStm >> nTmp16; rImpl_Font.meWeight = (FontWeight) nTmp16;
 791     rIStm >> nTmp16; rImpl_Font.meUnderline = (FontUnderline) nTmp16;
 792     rIStm >> nTmp16; rImpl_Font.meStrikeout = (FontStrikeout) nTmp16;
 793     rIStm >> nTmp16; rImpl_Font.meItalic = (FontItalic) nTmp16;
 794     rIStm >> nTmp16; rImpl_Font.meLanguage = (LanguageType) nTmp16;
 795     rIStm >> nTmp16; rImpl_Font.meWidthType = (FontWidth) nTmp16;
 796
 797     rIStm >> rImpl_Font.mnOrientation;
 798
 799     rIStm >> bTmp; rImpl_Font.mbWordLine = bTmp;
 800     rIStm >> bTmp; rImpl_Font.mbOutline = bTmp;
 801     rIStm >> bTmp; rImpl_Font.mbShadow = bTmp;
 802     rIStm >> nTmp8; rImpl_Font.mnKerning = nTmp8;
 803
 804     if( aCompat.GetVersion() >= 2 )
 805     {
 806         rIStm >> nTmp8;         rImpl_Font.meRelief = (FontRelief)nTmp8;
 807         rIStm >> nTmp16;        rImpl_Font.meCJKLanguage = (LanguageType)nTmp16;
 808         rIStm >> bTmp;          rImpl_Font.mbVertical = bTmp;
 809         rIStm >> nTmp16;        rImpl_Font.meEmphasisMark = (FontEmphasisMark)nTmp16;
 810     }
 811     if( aCompat.GetVersion() >= 3 )
 812     {
 813         rIStm >> nTmp16; rImpl_Font.meOverline = (FontUnderline) nTmp16;
 814     }
 815     // Relief
 816     // CJKContextLanguage
 817
 818     return rIStm;
 819 }
 820
 821 // -----------------------------------------------------------------------
 822
 823 SvStream& operator<<( SvStream& rOStm, const Impl_Font& rImpl_Font )
 824 {
 825     VersionCompat aCompat( rOStm, STREAM_WRITE, 3 );
 826     rOStm.WriteByteString( rImpl_Font.maFamilyName, rOStm.GetStreamCharSet() );
 827     rOStm.WriteByteString( rImpl_Font.maStyleName, rOStm.GetStreamCharSet() );
 828     rOStm << rImpl_Font.maSize;
 829
 830     rOStm << (UINT16) GetStoreCharSet( rImpl_Font.meCharSet );
 831     rOStm << (UINT16) rImpl_Font.meFamily;
 832     rOStm << (UINT16) rImpl_Font.mePitch;
 833     rOStm << (UINT16) rImpl_Font.meWeight;
 834     rOStm << (UINT16) rImpl_Font.meUnderline;
 835     rOStm << (UINT16) rImpl_Font.meStrikeout;
 836     rOStm << (UINT16) rImpl_Font.meItalic;
 837     rOStm << (UINT16) rImpl_Font.meLanguage;
 838     rOStm << (UINT16) rImpl_Font.meWidthType;
 839
 840     rOStm << rImpl_Font.mnOrientation;
 841
 842     rOStm << (BOOL) rImpl_Font.mbWordLine;
 843     rOStm << (BOOL) rImpl_Font.mbOutline;
 844     rOStm << (BOOL) rImpl_Font.mbShadow;
 845     rOStm << (BYTE) rImpl_Font.mnKerning;
 846
 847     // new in version 2
 848     rOStm << (BYTE)             rImpl_Font.meRelief;
 849     rOStm << (UINT16)   rImpl_Font.meCJKLanguage;
 850     rOStm << (BOOL)             rImpl_Font.mbVertical;
 851     rOStm << (UINT16)   rImpl_Font.meEmphasisMark;
 852
 853     // new in version 3
 854     rOStm << (UINT16) rImpl_Font.meOverline;
 855
 856     return rOStm;
 857 }
 858
 859 // -----------------------------------------------------------------------
 860
 861 SvStream& operator>>( SvStream& rIStm, Font& rFont )
 862 {
 863     rFont.MakeUnique();
 864     return( rIStm >> *rFont.mpImplFont );
 865 }
 866
 867 // -----------------------------------------------------------------------
 868
 869 SvStream& operator<<( SvStream& rOStm, const Font& rFont )
 870 {
 871     return( rOStm << *rFont.mpImplFont );
 872 }
 873
 874 // -----------------------------------------------------------------------
 875 namespace
 876 {
 877     bool identifyTrueTypeFont( const void* i_pBuffer, sal_uInt32 i_nSize, Font& o_rResult )
 878     {
 879         bool bResult = false;
 880 // FIXME: This is HACK. We do not build psprint's part on aqua...
 881 // How to solve this?
 882 #ifndef QUARTZ
 883         TrueTypeFont* pTTF = NULL;
 884         if( OpenTTFontBuffer( const_cast<void*>(i_pBuffer), i_nSize, 0, &pTTF ) == SF_OK )
 885         {
 886             TTGlobalFontInfo aInfo;
 887             GetTTGlobalFontInfo( pTTF, &aInfo );
 888             // most important: the family name
 889             if( aInfo.ufamily )
 890                 o_rResult.SetName( aInfo.ufamily );
 891             else if( aInfo.family )
 892                 o_rResult.SetName( rtl::OStringToOUString( aInfo.family, RTL_TEXTENCODING_ASCII_US ) );
 893             // set weight
 894             if( aInfo.weight )
 895             {
 896                 if( aInfo.weight < FW_EXTRALIGHT )
 897                     o_rResult.SetWeight( WEIGHT_THIN );
 898                 else if( aInfo.weight < FW_LIGHT )
 899                     o_rResult.SetWeight( WEIGHT_ULTRALIGHT );
 900                 else if( aInfo.weight < FW_NORMAL )
 901                     o_rResult.SetWeight( WEIGHT_LIGHT );
 902                 else if( aInfo.weight < FW_MEDIUM )
 903                     o_rResult.SetWeight( WEIGHT_NORMAL );
 904                 else if( aInfo.weight < FW_SEMIBOLD )
 905                     o_rResult.SetWeight( WEIGHT_MEDIUM );
 906                 else if( aInfo.weight < FW_BOLD )
 907                     o_rResult.SetWeight( WEIGHT_SEMIBOLD );
 908                 else if( aInfo.weight < FW_EXTRABOLD )
 909                     o_rResult.SetWeight( WEIGHT_BOLD );
 910                 else if( aInfo.weight < FW_BLACK )
 911                     o_rResult.SetWeight( WEIGHT_ULTRABOLD );
 912                 else
 913                     o_rResult.SetWeight( WEIGHT_BLACK );
 914             }
 915             else
 916                 o_rResult.SetWeight( (aInfo.macStyle & 1) ? WEIGHT_BOLD : WEIGHT_NORMAL );
 917             // set width
 918             if( aInfo.width )
 919             {
 920                 if( aInfo.width == FWIDTH_ULTRA_CONDENSED )
 921                     o_rResult.SetWidth( WIDTH_ULTRA_CONDENSED );
 922                 else if( aInfo.width == FWIDTH_EXTRA_CONDENSED )
 923                     o_rResult.SetWidth( WIDTH_EXTRA_CONDENSED );
 924                 else if( aInfo.width == FWIDTH_CONDENSED )
 925                     o_rResult.SetWidth( WIDTH_CONDENSED );
 926                 else if( aInfo.width == FWIDTH_SEMI_CONDENSED )
 927                     o_rResult.SetWidth( WIDTH_SEMI_CONDENSED );
 928                 else if( aInfo.width == FWIDTH_NORMAL )
 929                     o_rResult.SetWidth( WIDTH_NORMAL );
 930                 else if( aInfo.width == FWIDTH_SEMI_EXPANDED )
 931                     o_rResult.SetWidth( WIDTH_SEMI_EXPANDED );
 932                 else if( aInfo.width == FWIDTH_EXPANDED )
 933                     o_rResult.SetWidth( WIDTH_EXPANDED );
 934                 else if( aInfo.width == FWIDTH_EXTRA_EXPANDED )
 935                     o_rResult.SetWidth( WIDTH_EXTRA_EXPANDED );
 936                 else if( aInfo.width >= FWIDTH_ULTRA_EXPANDED )
 937                     o_rResult.SetWidth( WIDTH_ULTRA_EXPANDED );
 938             }
 939             // set italic
 940             o_rResult.SetItalic( (aInfo.italicAngle != 0) ? ITALIC_NORMAL : ITALIC_NONE );
 941
 942             // set pitch
 943             o_rResult.SetPitch( (aInfo.pitch == 0) ? PITCH_VARIABLE : PITCH_FIXED );
 944
 945             // set style name
 946             if( aInfo.usubfamily )
 947                 o_rResult.SetStyleName( rtl::OUString( aInfo.usubfamily ) );
 948             else if( aInfo.subfamily )
 949                 o_rResult.SetStyleName( rtl::OUString::createFromAscii( aInfo.subfamily ) );
 950
 951             // cleanup
 952             CloseTTFont( pTTF );
 953             // success
 954             bResult = true;
 955         }
 956 #endif
 957         return bResult;
 958     }
 959
 960     struct WeightSearchEntry
 961     {
 962         const char* string;
 963         int         string_len;
 964         FontWeight  weight;
 965
 966         bool operator<( const WeightSearchEntry& rRight ) const
 967         {
 968             return rtl_str_compareIgnoreAsciiCase_WithLength( string, string_len, rRight.string, rRight.string_len ) < 0;
 969         }
 970     }
 971     weight_table[] =
 972     {
 973         { "black", 5, WEIGHT_BLACK },
 974         { "bold", 4, WEIGHT_BOLD },
 975         { "book", 4, WEIGHT_LIGHT },
 976         { "demi", 4, WEIGHT_SEMIBOLD },
 977         { "heavy", 5, WEIGHT_BLACK },
 978         { "light", 5, WEIGHT_LIGHT },
 979         { "medium", 6, WEIGHT_MEDIUM },
 980         { "regular", 7, WEIGHT_NORMAL },
 981         { "super", 5, WEIGHT_ULTRABOLD },
 982         { "thin", 4, WEIGHT_THIN }
 983     };
 984
 985     bool identifyType1Font( const char* i_pBuffer, sal_uInt32 i_nSize, Font& o_rResult )
 986     {
 987         bool bResult = false;
 988         // might be a type1, find eexec
 989         const char* pStream = i_pBuffer;
 990         const char* pExec = "eexec";
 991         const char* pExecPos = std::search( pStream, pStream+i_nSize, pExec, pExec+5 );
 992         if( pExecPos != pStream+i_nSize)
 993         {
 994             // find /FamilyName entry
 995             static const char* pFam = "/FamilyName";
 996             const char* pFamPos = std::search( pStream, pExecPos, pFam, pFam+11 );
 997             if( pFamPos != pExecPos )
 998             {
 999                 // extract the string value behind /FamilyName
1000                 const char* pOpen = pFamPos+11;
1001                 while( pOpen < pExecPos && *pOpen != '(' )
1002                     pOpen++;
1003                 const char* pClose = pOpen;
1004                 while( pClose < pExecPos && *pClose != ')' )
1005                     pClose++;
1006                 if( pClose - pOpen > 1 )
1007                 {
1008                     o_rResult.SetName( rtl::OStringToOUString( rtl::OString( pOpen+1, pClose-pOpen-1 ), RTL_TEXTENCODING_ASCII_US ) );
1009                 }
1010             }
1011
1012             // parse /ItalicAngle
1013             static const char* pItalic = "/ItalicAngle";
1014             const char* pItalicPos = std::search( pStream, pExecPos, pItalic, pItalic+12 );
1015             if( pItalicPos != pExecPos )
1016             {
1017                 sal_Int32 nItalic = rtl_str_toInt32( pItalicPos+12, 10 );
1018                 o_rResult.SetItalic( (nItalic != 0) ? ITALIC_NORMAL : ITALIC_NONE );
1019             }
1020
1021             // parse /Weight
1022             static const char* pWeight = "/Weight";
1023             const char* pWeightPos = std::search( pStream, pExecPos, pWeight, pWeight+7 );
1024             if( pWeightPos != pExecPos )
1025             {
1026                 // extract the string value behind /Weight
1027                 const char* pOpen = pWeightPos+7;
1028                 while( pOpen < pExecPos && *pOpen != '(' )
1029                     pOpen++;
1030                 const char* pClose = pOpen;
1031                 while( pClose < pExecPos && *pClose != ')' )
1032                     pClose++;
1033                 if( pClose - pOpen > 1 )
1034                 {
1035                     WeightSearchEntry aEnt;
1036                     aEnt.string = pOpen+1;
1037                     aEnt.string_len = (pClose-pOpen)-1;
1038                     aEnt.weight = WEIGHT_NORMAL;
1039                     const int nEnt = sizeof( weight_table ) / sizeof( weight_table[0] );
1040                     WeightSearchEntry* pFound = std::lower_bound( weight_table, weight_table+nEnt, aEnt );
1041                     if( pFound != (weight_table+nEnt) )
1042                         o_rResult.SetWeight( pFound->weight );
1043                 }
1044             }
1045
1046             // parse isFixedPitch
1047             static const char* pFixed = "/isFixedPitch";
1048             const char* pFixedPos = std::search( pStream, pExecPos, pFixed, pFixed+13 );
1049             if( pFixedPos != pExecPos )
1050             {
1051                 // skip whitespace
1052                 while( pFixedPos < pExecPos-4 &&
1053                        ( *pFixedPos == ' '  ||
1054                          *pFixedPos == '\t' ||
1055                          *pFixedPos == '\r' ||
1056                          *pFixedPos == '\n' ) )
1057                 {
1058                     pFixedPos++;
1059                 }
1060                 // find "true" value
1061                 if( rtl_str_compareIgnoreAsciiCase_WithLength( pFixedPos, 4, "true", 4 ) == 0 )
1062                     o_rResult.SetPitch( PITCH_FIXED );
1063                 else
1064                     o_rResult.SetPitch( PITCH_VARIABLE );
1065             }
1066         }
1067         return bResult;
1068     }
1069 }
1070
1071 Font Font::identifyFont( const void* i_pBuffer, sal_uInt32 i_nSize )
1072 {
1073     Font aResult;
1074     if( ! identifyTrueTypeFont( i_pBuffer, i_nSize, aResult ) )
1075     {
1076         const char* pStream = reinterpret_cast<const char*>(i_pBuffer);
1077         if( pStream && i_nSize > 100 &&
1078              *pStream == '%' && pStream[1] == '!' )
1079         {
1080             identifyType1Font( pStream, i_nSize, aResult );
1081         }
1082     }
1083
1084     return aResult;
1085 }
1086
1087 // the inlines from the font.hxx header are now instantiated for pImpl-ification
1088 // TODO: reformat
1089 const Color& Font::GetColor() const { return mpImplFont->maColor; }
1090 const Color& Font::GetFillColor() const { return mpImplFont->maFillColor; }
1091 BOOL Font::IsTransparent() const { return mpImplFont->mbTransparent; }
1092 FontAlign Font::GetAlign() const { return mpImplFont->meAlign; }
1093 const String& Font::GetName() const { return mpImplFont->maFamilyName; }
1094 const String& Font::GetStyleName() const { return mpImplFont->maStyleName; }
1095 const Size& Font::GetSize() const { return mpImplFont->maSize; }
1096 void Font::SetHeight( long nHeight ) { SetSize( Size( mpImplFont->maSize.Width(), nHeight ) ); }
1097 long Font::GetHeight() const { return mpImplFont->maSize.Height(); }
1098 void Font::SetWidth( long nWidth ) { SetSize( Size( nWidth, mpImplFont->maSize.Height() ) ); }
1099 long Font::GetWidth() const { return mpImplFont->maSize.Width(); }
1100 rtl_TextEncoding Font::GetCharSet() const { return mpImplFont->meCharSet; }
1101 LanguageType Font::GetLanguage() const { return mpImplFont->meLanguage; }
1102 LanguageType Font::GetCJKContextLanguage() const { return mpImplFont->meCJKLanguage; }
1103 short Font::GetOrientation() const { return mpImplFont->mnOrientation; }
1104 BOOL Font::IsVertical() const { return mpImplFont->mbVertical; }
1105 FontKerning Font::GetKerning() const { return mpImplFont->mnKerning; }
1106 FontPitch Font::GetPitch() const { return mpImplFont->GetPitch(); }
1107 FontWeight Font::GetWeight() const { return mpImplFont->GetWeight(); }
1108 FontWidth Font::GetWidthType() const { return mpImplFont->GetWidthType(); }
1109 FontItalic Font::GetItalic() const { return mpImplFont->GetItalic(); }
1110 FontFamily Font::GetFamily() const { return mpImplFont->GetFamily(); }
1111 BOOL Font::IsOutline() const { return mpImplFont->mbOutline; }
1112 BOOL Font::IsShadow() const { return mpImplFont->mbShadow; }
1113 FontRelief Font::GetRelief() const { return mpImplFont->meRelief; }
1114 FontUnderline Font::GetUnderline() const { return mpImplFont->meUnderline; }
1115 FontUnderline Font::GetOverline()  const { return mpImplFont->meOverline; }
1116 FontStrikeout Font::GetStrikeout() const { return mpImplFont->meStrikeout; }
1117 FontEmphasisMark Font::GetEmphasisMark() const { return mpImplFont->meEmphasisMark; }
1118 BOOL Font::IsWordLineMode() const { return mpImplFont->mbWordLine; }
1119 BOOL Font::IsSameInstance( const Font& rFont ) const { return (mpImplFont == rFont.mpImplFont); }