svtools/source/control/ctrltool.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: ctrltool.cxx,v $
  10  * $Revision: 1.19 $
  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_svtools.hxx"
  33
  34 #define CTRLTOOL_CXX
  35
  36 #include <string.h>
  37
  38 #ifndef TOOLS_DEBUG_HXX
  39 #include <tools/debug.hxx>
  40 #endif
  41 #include <i18npool/mslangid.hxx>
  42 #ifndef _VCL_WINDOW_HXX
  43 #include <vcl/window.hxx>
  44 #endif
  45 #include <vcl/svapp.hxx>
  46 #include <vcl/wrkwin.hxx>
  47
  48 #include <svtools/svtools.hrc>
  49 #include <svtools/svtdata.hxx>
  50 #include <ctrltool.hxx>
  51
  52 // =======================================================================
  53
  54 // Standard Fontgroessen fuer scalierbare Fonts
  55 static long aStdSizeAry[] =
  56 {
  57      60,
  58      70,
  59      80,
  60      90,
  61     100,
  62     105,
  63     110,
  64     120,
  65     130,
  66     140,
  67     150,
  68     160,
  69     180,
  70     200,
  71     220,
  72     240,
  73     260,
  74     280,
  75     320,
  76     360,
  77     400,
  78     440,
  79     480,
  80     540,
  81     600,
  82     660,
  83     720,
  84     800,
  85     880,
  86     960,
  87     0
  88 };
  89
  90 // =======================================================================
  91
  92 // -----------------------------
  93 // - class ImplFontListFonInfo -
  94 // -----------------------------
  95
  96 class ImplFontListFontInfo : public FontInfo
  97 {
  98     friend class FontList;
  99
 100 private:
 101     OutputDevice*                       mpDevice;
 102     ImplFontListFontInfo*       mpNext;
 103
 104 public:
 105                             ImplFontListFontInfo( const FontInfo& rInfo,
 106                                                   OutputDevice* pDev ) :
 107                                 FontInfo( rInfo )
 108                             {
 109                                 mpDevice = pDev;
 110                             }
 111
 112     OutputDevice*                       GetDevice() const { return mpDevice; }
 113 };
 114
 115 // ------------------------------
 116 // - class ImplFontListNameInfo -
 117 // ------------------------------
 118
 119 class ImplFontListNameInfo
 120 {
 121     friend class FontList;
 122
 123 private:
 124     XubString                           maSearchName;
 125     ImplFontListFontInfo*       mpFirst;
 126     USHORT                                      mnType;
 127
 128                             ImplFontListNameInfo( const XubString& rSearchName ) :
 129                                 maSearchName( rSearchName )
 130                             {}
 131
 132     const XubString&            GetSearchName() const { return maSearchName; }
 133 };
 134
 135 // =======================================================================
 136
 137 static StringCompare ImplCompareFontInfo( ImplFontListFontInfo* pInfo1,
 138                                           ImplFontListFontInfo* pInfo2 )
 139 {
 140     if ( pInfo1->GetWeight() < pInfo2->GetWeight() )
 141         return COMPARE_LESS;
 142     else if ( pInfo1->GetWeight() > pInfo2->GetWeight() )
 143         return COMPARE_GREATER;
 144
 145     if ( pInfo1->GetItalic() < pInfo2->GetItalic() )
 146         return COMPARE_LESS;
 147     else if ( pInfo1->GetItalic() > pInfo2->GetItalic() )
 148         return COMPARE_GREATER;
 149
 150     return pInfo1->GetStyleName().CompareTo( pInfo2->GetStyleName() );
 151 }
 152
 153 // =======================================================================
 154
 155 static void ImplMakeSearchString( XubString& rStr )
 156 {
 157     rStr.ToLowerAscii();
 158 }
 159
 160 // -----------------------------------------------------------------------
 161
 162 static void ImplMakeSearchStringFromName( XubString& rStr )
 163 {
 164     // check for features before alternate font separator
 165     if (rStr.Search(':') < rStr.Search(';'))
 166         rStr = rStr.GetToken( 0, ':' );
 167     else
 168         rStr = rStr.GetToken( 0, ';' );
 169     ImplMakeSearchString( rStr );
 170 }
 171
 172 // -----------------------------------------------------------------------
 173
 174 ImplFontListNameInfo* FontList::ImplFind( const XubString& rSearchName, ULONG* pIndex ) const
 175 {
 176     // Wenn kein Eintrag in der Liste oder der Eintrag groesser ist als
 177     // der Letzte, dann hinten dranhaengen. Wir vergleichen erst mit dem
 178     // letzten Eintrag, da die Liste von VCL auch sortiert zurueckkommt
 179     // und somit die Wahrscheinlichkeit das hinten angehaengt werden muss
 180     // sehr gross ist.
 181     StringCompare eComp;
 182     ULONG nCnt = Count();
 183     if ( !nCnt )
 184     {
 185         if ( pIndex )
 186             *pIndex = LIST_APPEND;
 187         return NULL;
 188     }
 189     else
 190     {
 191         ImplFontListNameInfo* pCmpData = (ImplFontListNameInfo*)List::GetObject( nCnt-1 );
 192         eComp = rSearchName.CompareTo( pCmpData->maSearchName );
 193         if ( eComp == COMPARE_GREATER )
 194         {
 195             if ( pIndex )
 196                 *pIndex = LIST_APPEND;
 197             return NULL;
 198         }
 199         else if ( eComp == COMPARE_EQUAL )
 200             return pCmpData;
 201     }
 202
 203     // Fonts in der Liste suchen
 204     ImplFontListNameInfo*       pCompareData;
 205     ImplFontListNameInfo*       pFoundData = NULL;
 206     ULONG                                       nLow = 0;
 207     ULONG                                       nHigh = nCnt-1;
 208     ULONG                                       nMid;
 209
 210     do
 211     {
 212         nMid = (nLow + nHigh) / 2;
 213         pCompareData = (ImplFontListNameInfo*)List::GetObject( nMid );
 214         eComp = rSearchName.CompareTo( pCompareData->maSearchName );
 215         if ( eComp == COMPARE_LESS )
 216         {
 217             if ( !nMid )
 218                 break;
 219             nHigh = nMid-1;
 220         }
 221         else
 222         {
 223             if ( eComp == COMPARE_GREATER )
 224                 nLow = nMid + 1;
 225             else
 226             {
 227                 pFoundData = pCompareData;
 228                 break;
 229             }
 230         }
 231     }
 232     while ( nLow <= nHigh );
 233
 234     if ( pIndex )
 235     {
 236         eComp = rSearchName.CompareTo( pCompareData->maSearchName );
 237         if ( eComp == COMPARE_GREATER )
 238             *pIndex = (nMid+1);
 239         else
 240             *pIndex = nMid;
 241     }
 242
 243     return pFoundData;
 244 }
 245
 246 // -----------------------------------------------------------------------
 247
 248 ImplFontListNameInfo* FontList::ImplFindByName( const XubString& rStr ) const
 249 {
 250     XubString aSearchName = rStr;
 251     ImplMakeSearchStringFromName( aSearchName );
 252     return ImplFind( aSearchName, NULL );
 253 }
 254
 255 // -----------------------------------------------------------------------
 256
 257 void FontList::ImplInsertFonts( OutputDevice* pDevice, BOOL bAll,
 258                                 BOOL bInsertData )
 259 {
 260     rtl_TextEncoding eSystemEncoding = gsl_getSystemTextEncoding();
 261
 262     USHORT nType;
 263     if ( pDevice->GetOutDevType() != OUTDEV_PRINTER )
 264         nType = FONTLIST_FONTNAMETYPE_SCREEN;
 265     else
 266         nType = FONTLIST_FONTNAMETYPE_PRINTER;
 267
 268     // Alle Fonts vom Device abfragen
 269     int n = pDevice->GetDevFontCount();
 270     USHORT      i;
 271     for( i = 0; i < n; i++ )
 272     {
 273         FontInfo aFontInfo = pDevice->GetDevFont( i );
 274
 275         // Wenn keine Raster-Schriften angezeigt werden sollen,
 276         // dann diese ignorieren
 277         if ( !bAll && (aFontInfo.GetType() == TYPE_RASTER) )
 278             continue;
 279
 280         XubString                               aSearchName = aFontInfo.GetName();
 281         ImplFontListNameInfo*   pData;
 282         ULONG                                   nIndex;
 283         ImplMakeSearchString( aSearchName );
 284         pData = ImplFind( aSearchName, &nIndex );
 285
 286         if ( !pData )
 287         {
 288             if ( bInsertData )
 289             {
 290                 ImplFontListFontInfo* pNewInfo = new ImplFontListFontInfo( aFontInfo, pDevice );
 291                 pData = new ImplFontListNameInfo( aSearchName );
 292                 pData->mpFirst          = pNewInfo;
 293                 pNewInfo->mpNext        = NULL;
 294                 pData->mnType           = 0;
 295                 Insert( (void*)pData, nIndex );
 296             }
 297         }
 298         else
 299         {
 300             if ( bInsertData )
 301             {
 302                 BOOL                                    bInsert = TRUE;
 303                 ImplFontListFontInfo*   pPrev = NULL;
 304                 ImplFontListFontInfo*   pTemp = pData->mpFirst;
 305                 ImplFontListFontInfo*   pNewInfo = new ImplFontListFontInfo( aFontInfo, pDevice );
 306                 while ( pTemp )
 307                 {
 308                     StringCompare eComp = ImplCompareFontInfo( pNewInfo, pTemp );
 309                     if ( (eComp == COMPARE_LESS) || (eComp == COMPARE_EQUAL) )
 310                     {
 311                         if ( eComp == COMPARE_EQUAL )
 312                         {
 313                             // Overwrite charset, because charset should match
 314                             // with the system charset
 315                             if ( (pTemp->GetCharSet() != eSystemEncoding) &&
 316                                  (pNewInfo->GetCharSet() == eSystemEncoding) )
 317                             {
 318                                 ImplFontListFontInfo* pTemp2 = pTemp->mpNext;
 319                                 *((FontInfo*)pTemp) = *((FontInfo*)pNewInfo);
 320                                 pTemp->mpNext = pTemp2;
 321                             }
 322                             delete pNewInfo;
 323                             bInsert = FALSE;
 324                         }
 325
 326                         break;
 327                     }
 328
 329                     pPrev = pTemp;
 330                     pTemp = pTemp->mpNext;
 331                 }
 332
 333                 if ( bInsert )
 334                 {
 335                     pNewInfo->mpNext = pTemp;
 336                     if ( pPrev )
 337                         pPrev->mpNext = pNewInfo;
 338                     else
 339                         pData->mpFirst = pNewInfo;
 340                 }
 341             }
 342         }
 343
 344         if ( pData )
 345         {
 346             pData->mnType |= nType;
 347             if ( aFontInfo.GetType() != TYPE_RASTER )
 348                 pData->mnType |= FONTLIST_FONTNAMETYPE_SCALABLE;
 349         }
 350     }
 351 }
 352
 353 // =======================================================================
 354
 355 FontList::FontList( OutputDevice* pDevice, OutputDevice* pDevice2, BOOL bAll ) :
 356     List( 4096, sal::static_int_cast< USHORT >(pDevice->GetDevFontCount()), 32 )
 357 {
 358     // Variablen initialisieren
 359     mpDev = pDevice;
 360     mpDev2 = pDevice2;
 361     mpSizeAry = NULL;
 362
 363     // Stylenamen festlegen
 364     maLight             = XubString( SvtResId( STR_SVT_STYLE_LIGHT ) );
 365     maLightItalic       = XubString( SvtResId( STR_SVT_STYLE_LIGHT_ITALIC ) );
 366     maNormal            = XubString( SvtResId( STR_SVT_STYLE_NORMAL ) );
 367     maNormalItalic      = XubString( SvtResId( STR_SVT_STYLE_NORMAL_ITALIC ) );
 368     maBold                      = XubString( SvtResId( STR_SVT_STYLE_BOLD ) );
 369     maBoldItalic        = XubString( SvtResId( STR_SVT_STYLE_BOLD_ITALIC ) );
 370     maBlack             = XubString( SvtResId( STR_SVT_STYLE_BLACK ) );
 371     maBlackItalic       = XubString( SvtResId( STR_SVT_STYLE_BLACK_ITALIC ) );
 372
 373     ImplInsertFonts( pDevice, bAll, TRUE );
 374
 375     // Gegebenenfalls muessen wir mit den Bildschirmfonts vergleichen,
 376     // damit dort die eigentlich doppelten auf Equal mappen koennen
 377     BOOL bCompareWindow = FALSE;
 378     if ( !pDevice2 && (pDevice->GetOutDevType() == OUTDEV_PRINTER) )
 379     {
 380         bCompareWindow = TRUE;
 381         pDevice2 = Application::GetDefaultDevice();
 382     }
 383
 384     if ( pDevice2 &&
 385          (pDevice2->GetOutDevType() != pDevice->GetOutDevType()) )
 386         ImplInsertFonts( pDevice2, bAll, !bCompareWindow );
 387 }
 388
 389 // -----------------------------------------------------------------------
 390
 391 FontList::~FontList()
 392 {
 393     // Gegebenenfalls SizeArray loeschen
 394     if ( mpSizeAry )
 395         delete[] mpSizeAry;
 396
 397     // FontInfos loeschen
 398     ImplFontListNameInfo* pData = (ImplFontListNameInfo*)First();
 399     while ( pData )
 400     {
 401         ImplFontListFontInfo* pTemp;
 402         ImplFontListFontInfo* pInfo = pData->mpFirst;
 403         while ( pInfo )
 404         {
 405             pTemp = pInfo->mpNext;
 406             delete pInfo;
 407             pInfo = pTemp;
 408         }
 409         ImplFontListNameInfo* pNext = (ImplFontListNameInfo*)Next();
 410         delete pData;
 411         pData = pNext;
 412     }
 413 }
 414 // -----------------------------------------------------------------------
 415 FontList* FontList::Clone() const
 416 {
 417     FontList* pReturn = new FontList(
 418             mpDev, mpDev2, GetFontNameCount() == mpDev->GetDevFontCount());
 419     return pReturn;
 420 }
 421
 422 // -----------------------------------------------------------------------
 423
 424 const XubString& FontList::GetStyleName( FontWeight eWeight, FontItalic eItalic ) const
 425 {
 426     if ( eWeight > WEIGHT_BOLD )
 427     {
 428         if ( eItalic > ITALIC_NONE )
 429             return maBlackItalic;
 430         else
 431             return maBlack;
 432     }
 433     else if ( eWeight > WEIGHT_MEDIUM )
 434     {
 435         if ( eItalic > ITALIC_NONE )
 436             return maBoldItalic;
 437         else
 438             return maBold;
 439     }
 440     else if ( eWeight > WEIGHT_LIGHT )
 441     {
 442         if ( eItalic > ITALIC_NONE )
 443             return maNormalItalic;
 444         else
 445             return maNormal;
 446     }
 447     else if ( eWeight != WEIGHT_DONTKNOW )
 448     {
 449         if ( eItalic > ITALIC_NONE )
 450             return maLightItalic;
 451         else
 452             return maLight;
 453     }
 454     else
 455     {
 456         if ( eItalic > ITALIC_NONE )
 457             return maNormalItalic;
 458         else
 459             return maNormal;
 460     }
 461 }
 462
 463 // -----------------------------------------------------------------------
 464
 465 XubString FontList::GetStyleName( const FontInfo& rInfo ) const
 466 {
 467     XubString   aStyleName = rInfo.GetStyleName();
 468     FontWeight  eWeight = rInfo.GetWeight();
 469     FontItalic  eItalic = rInfo.GetItalic();
 470
 471     // Nur wenn kein StyleName gesetzt ist, geben wir einen syntetischen
 472     // Namen zurueck
 473     if ( !aStyleName.Len() )
 474         aStyleName = GetStyleName( eWeight, eItalic );
 475     else
 476     {
 477         // Translate StyleName to localized name
 478         XubString aCompareStyleName = aStyleName;
 479         aCompareStyleName.ToLowerAscii();
 480         aCompareStyleName.EraseAllChars( ' ' );
 481         if ( aCompareStyleName.EqualsAscii( "bold" ) )
 482             aStyleName = maBold;
 483         else if ( aCompareStyleName.EqualsAscii( "bolditalic" ) )
 484             aStyleName = maBoldItalic;
 485         else if ( aCompareStyleName.EqualsAscii( "italic" ) )
 486             aStyleName = maNormalItalic;
 487         else if ( aCompareStyleName.EqualsAscii( "standard" ) )
 488             aStyleName = maNormal;
 489         else if ( aCompareStyleName.EqualsAscii( "regular" ) )
 490             aStyleName = maNormal;
 491         else if ( aCompareStyleName.EqualsAscii( "medium" ) )
 492             aStyleName = maNormal;
 493         else if ( aCompareStyleName.EqualsAscii( "light" ) )
 494             aStyleName = maLight;
 495         else if ( aCompareStyleName.EqualsAscii( "lightitalic" ) )
 496             aStyleName = maLightItalic;
 497         else if ( aCompareStyleName.EqualsAscii( "black" ) )
 498             aStyleName = maBlack;
 499         else if ( aCompareStyleName.EqualsAscii( "blackitalic" ) )
 500             aStyleName = maBlackItalic;
 501
 502         // fix up StyleName, because the PS Printer driver from
 503         // W2000 returns wrong StyleNames (e.g. Bold instead of Bold Italic
 504         // for Helvetica)
 505         if ( eItalic > ITALIC_NONE )
 506         {
 507             if ( (aStyleName == maNormal) ||
 508                  (aStyleName == maBold) ||
 509                  (aStyleName == maLight) ||
 510                  (aStyleName == maBlack) )
 511                 aStyleName = GetStyleName( eWeight, eItalic );
 512         }
 513     }
 514
 515     return aStyleName;
 516 }
 517
 518 // -----------------------------------------------------------------------
 519
 520 XubString FontList::GetFontMapText( const FontInfo& rInfo ) const
 521 {
 522     if ( !rInfo.GetName().Len() )
 523     {
 524         XubString aEmptryStr;
 525         return aEmptryStr;
 526     }
 527
 528     // Search Fontname
 529     ImplFontListNameInfo* pData = ImplFindByName( rInfo.GetName() );
 530     if ( !pData )
 531     {
 532         if ( !maMapNotAvailable.Len() )
 533             ((FontList*)this)->maMapNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_NOTAVAILABLE ) );
 534         return maMapNotAvailable;
 535     }
 536
 537     // search for synthetic style
 538     USHORT                              nType           = pData->mnType;
 539     const XubString&    rStyleName      = rInfo.GetStyleName();
 540     if ( rStyleName.Len() )
 541     {
 542         BOOL                                    bNotSynthetic = FALSE;
 543         BOOL                                    bNoneAvailable = FALSE;
 544         FontWeight                              eWeight = rInfo.GetWeight();
 545         FontItalic                              eItalic = rInfo.GetItalic();
 546         ImplFontListFontInfo*   pFontInfo = pData->mpFirst;
 547         while ( pFontInfo )
 548         {
 549             if ( (eWeight == pFontInfo->GetWeight()) &&
 550                  (eItalic == pFontInfo->GetItalic()) )
 551             {
 552                 bNotSynthetic = TRUE;
 553                 break;
 554             }
 555
 556             pFontInfo = pFontInfo->mpNext;
 557         }
 558
 559         if ( bNoneAvailable )
 560         {
 561             XubString aEmptryStr;
 562             return aEmptryStr;
 563         }
 564         else if ( !bNotSynthetic )
 565         {
 566             if ( !maMapStyleNotAvailable.Len() )
 567                 ((FontList*)this)->maMapStyleNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_STYLENOTAVAILABLE ) );
 568             return maMapStyleNotAvailable;
 569         }
 570     }
 571
 572     /* Size not available not implemented yet
 573     if ( !(nType & FONTLIST_FONTNAMETYPE_SCALABLE) )
 574     {
 575         ...
 576         {
 577             if ( !maMapSizeNotAvailable.Len() )
 578                  ((FontList*)this)->maMapSizeNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_SIZENOTAVAILABLE ) );
 579             return maMapSizeNotAvailable;
 580         }
 581     }
 582     */
 583
 584     // Only Printer-Font?
 585     if ( (nType & (FONTLIST_FONTNAMETYPE_PRINTER | FONTLIST_FONTNAMETYPE_SCREEN)) == FONTLIST_FONTNAMETYPE_PRINTER )
 586     {
 587         if ( !maMapPrinterOnly.Len() )
 588             ((FontList*)this)->maMapPrinterOnly = XubString( SvtResId( STR_SVT_FONTMAP_PRINTERONLY ) );
 589         return maMapPrinterOnly;
 590     }
 591     // Only Screen-Font?
 592     else if ( (nType & (FONTLIST_FONTNAMETYPE_PRINTER | FONTLIST_FONTNAMETYPE_SCREEN)) == FONTLIST_FONTNAMETYPE_SCREEN
 593             && rInfo.GetType() == TYPE_RASTER )
 594     {
 595         if ( !maMapScreenOnly.Len() )
 596             ((FontList*)this)->maMapScreenOnly = XubString( SvtResId( STR_SVT_FONTMAP_SCREENONLY ) );
 597         return maMapScreenOnly;
 598     }
 599     else
 600     {
 601         if ( !maMapBoth.Len() )
 602             ((FontList*)this)->maMapBoth = XubString( SvtResId( STR_SVT_FONTMAP_BOTH ) );
 603         return maMapBoth;
 604     }
 605 }
 606
 607 // -----------------------------------------------------------------------
 608
 609 USHORT FontList::GetFontNameType( const XubString& rFontName ) const
 610 {
 611     ImplFontListNameInfo* pData = ImplFindByName( rFontName );
 612     if ( pData )
 613         return pData->mnType;
 614     else
 615         return 0;
 616 }
 617
 618 // -----------------------------------------------------------------------
 619
 620 FontInfo FontList::Get( const XubString& rName, const XubString& rStyleName ) const
 621 {
 622     ImplFontListNameInfo* pData = ImplFindByName( rName );
 623     ImplFontListFontInfo* pFontInfo = NULL;
 624     ImplFontListFontInfo* pFontNameInfo = NULL;
 625     if ( pData )
 626     {
 627         ImplFontListFontInfo* pSearchInfo = pData->mpFirst;
 628         pFontNameInfo = pSearchInfo;
 629         pSearchInfo = pData->mpFirst;
 630         while ( pSearchInfo )
 631         {
 632             if ( rStyleName.EqualsIgnoreCaseAscii( GetStyleName( *pSearchInfo ) ) )
 633             {
 634                 pFontInfo = pSearchInfo;
 635                 break;
 636             }
 637
 638             pSearchInfo = pSearchInfo->mpNext;
 639         }
 640     }
 641
 642     // Konnten die Daten nicht gefunden werden, dann muessen bestimmte
 643     // Attribute nachgebildet werden
 644     FontInfo aInfo;
 645     if ( !pFontInfo )
 646     {
 647         if ( pFontNameInfo )
 648             aInfo = *pFontNameInfo;
 649
 650         if ( rStyleName == maNormal )
 651         {
 652             aInfo.SetItalic( ITALIC_NONE );
 653             aInfo.SetWeight( WEIGHT_NORMAL );
 654         }
 655         else if ( rStyleName == maNormalItalic )
 656         {
 657             aInfo.SetItalic( ITALIC_NORMAL );
 658             aInfo.SetWeight( WEIGHT_NORMAL );
 659         }
 660         else if ( rStyleName == maBold )
 661         {
 662             aInfo.SetItalic( ITALIC_NONE );
 663             aInfo.SetWeight( WEIGHT_BOLD );
 664         }
 665         else if ( rStyleName == maBoldItalic )
 666         {
 667             aInfo.SetItalic( ITALIC_NORMAL );
 668             aInfo.SetWeight( WEIGHT_BOLD );
 669         }
 670         else if ( rStyleName == maLight )
 671         {
 672             aInfo.SetItalic( ITALIC_NONE );
 673             aInfo.SetWeight( WEIGHT_LIGHT );
 674         }
 675         else if ( rStyleName == maLightItalic )
 676         {
 677             aInfo.SetItalic( ITALIC_NORMAL );
 678             aInfo.SetWeight( WEIGHT_LIGHT );
 679         }
 680         else if ( rStyleName == maBlack )
 681         {
 682             aInfo.SetItalic( ITALIC_NONE );
 683             aInfo.SetWeight( WEIGHT_BLACK );
 684         }
 685         else if ( rStyleName == maBlackItalic )
 686         {
 687             aInfo.SetItalic( ITALIC_NORMAL );
 688             aInfo.SetWeight( WEIGHT_BLACK );
 689         }
 690         else
 691         {
 692             aInfo.SetItalic( ITALIC_NONE );
 693             aInfo.SetWeight( WEIGHT_DONTKNOW );
 694         }
 695     }
 696     else
 697         aInfo = *pFontInfo;
 698
 699     // set Fontname to keep FontAlias
 700     aInfo.SetName( rName );
 701     aInfo.SetStyleName( rStyleName );
 702
 703     return aInfo;
 704 }
 705
 706 // -----------------------------------------------------------------------
 707
 708 FontInfo FontList::Get( const XubString& rName,
 709                         FontWeight eWeight, FontItalic eItalic ) const
 710 {
 711     ImplFontListNameInfo* pData = ImplFindByName( rName );
 712     ImplFontListFontInfo* pFontInfo = NULL;
 713     ImplFontListFontInfo* pFontNameInfo = NULL;
 714     if ( pData )
 715     {
 716         ImplFontListFontInfo* pSearchInfo = pData->mpFirst;
 717         pFontNameInfo = pSearchInfo;
 718         while ( pSearchInfo )
 719         {
 720             if ( (eWeight == pSearchInfo->GetWeight()) &&
 721                  (eItalic == pSearchInfo->GetItalic()) )
 722             {
 723                 pFontInfo = pSearchInfo;
 724                 break;
 725             }
 726
 727             pSearchInfo = pSearchInfo->mpNext;
 728         }
 729     }
 730
 731     // Konnten die Daten nicht gefunden werden, dann muessen bestimmte
 732     // Attribute nachgebildet werden
 733     FontInfo aInfo;
 734     if ( !pFontInfo )
 735     {
 736         // Falls der Fontname stimmt, uebernehmen wir soviel wie moeglich
 737         if ( pFontNameInfo )
 738         {
 739             aInfo = *pFontNameInfo;
 740             aInfo.SetStyleName( XubString() );
 741         }
 742
 743         aInfo.SetWeight( eWeight );
 744         aInfo.SetItalic( eItalic );
 745     }
 746     else
 747         aInfo = *pFontInfo;
 748
 749     // set Fontname to keep FontAlias
 750     aInfo.SetName( rName );
 751
 752     return aInfo;
 753 }
 754
 755 // -----------------------------------------------------------------------
 756
 757 BOOL FontList::IsAvailable( const XubString& rName ) const
 758 {
 759     return (ImplFindByName( rName ) != 0);
 760 }
 761
 762 // -----------------------------------------------------------------------
 763
 764 const FontInfo& FontList::GetFontName( USHORT nFont ) const
 765 {
 766     DBG_ASSERT( nFont < GetFontNameCount(), "FontList::GetFontName(): nFont >= Count" );
 767
 768     ImplFontListNameInfo* pData = (ImplFontListNameInfo*)List::GetObject( nFont );
 769     return *(pData->mpFirst);
 770 }
 771
 772 // -----------------------------------------------------------------------
 773
 774 USHORT FontList::GetFontNameType( USHORT nFont ) const
 775 {
 776     DBG_ASSERT( nFont < GetFontNameCount(), "FontList::GetFontNameType(): nFont >= Count" );
 777
 778     ImplFontListNameInfo* pData = (ImplFontListNameInfo*)List::GetObject( nFont );
 779     return pData->mnType;
 780 }
 781
 782 // -----------------------------------------------------------------------
 783
 784 sal_Handle FontList::GetFirstFontInfo( const XubString& rName ) const
 785 {
 786     ImplFontListNameInfo* pData = ImplFindByName( rName );
 787     if ( !pData )
 788         return (sal_Handle)NULL;
 789     else
 790         return (sal_Handle)pData->mpFirst;
 791 }
 792
 793 // -----------------------------------------------------------------------
 794
 795 sal_Handle FontList::GetNextFontInfo( sal_Handle hFontInfo ) const
 796 {
 797     ImplFontListFontInfo* pInfo = (ImplFontListFontInfo*)(void*)hFontInfo;
 798     return (sal_Handle)(pInfo->mpNext);
 799 }
 800
 801 // -----------------------------------------------------------------------
 802
 803 const FontInfo& FontList::GetFontInfo( sal_Handle hFontInfo ) const
 804 {
 805     ImplFontListFontInfo* pInfo = (ImplFontListFontInfo*)(void*)hFontInfo;
 806     return *pInfo;
 807 }
 808
 809 // -----------------------------------------------------------------------
 810
 811 const long* FontList::GetSizeAry( const FontInfo& rInfo ) const
 812 {
 813     // Size-Array vorher loeschen
 814     if ( mpSizeAry )
 815     {
 816         delete[] ((FontList*)this)->mpSizeAry;
 817         ((FontList*)this)->mpSizeAry = NULL;
 818     }
 819
 820     // Falls kein Name, dann Standardgroessen
 821     if ( !rInfo.GetName().Len() )
 822         return aStdSizeAry;
 823
 824     // Zuerst nach dem Fontnamen suchen um das Device dann von dem
 825     // entsprechenden Font zu nehmen
 826     OutputDevice*                       pDevice = mpDev;
 827     ImplFontListNameInfo*       pData = ImplFindByName( rInfo.GetName() );
 828     if ( pData )
 829         pDevice = pData->mpFirst->GetDevice();
 830
 831     int nDevSizeCount = pDevice->GetDevFontSizeCount( rInfo );
 832     if ( !nDevSizeCount ||
 833          (pDevice->GetDevFontSize( rInfo, 0 ).Height() == 0) )
 834         return aStdSizeAry;
 835
 836     MapMode aOldMapMode = pDevice->GetMapMode();
 837     MapMode aMap( MAP_10TH_INCH, Point(), Fraction( 1, 72 ), Fraction( 1, 72 ) );
 838     pDevice->SetMapMode( aMap );
 839
 840     USHORT      i;
 841     USHORT      nRealCount = 0;
 842     long        nOldHeight = 0;
 843     ((FontList*)this)->mpSizeAry = new long[nDevSizeCount+1];
 844     for ( i = 0; i < nDevSizeCount; i++ )
 845     {
 846         Size aSize = pDevice->GetDevFontSize( rInfo, i );
 847         if ( aSize.Height() != nOldHeight )
 848         {
 849             nOldHeight = aSize.Height();
 850             ((FontList*)this)->mpSizeAry[nRealCount] = nOldHeight;
 851             nRealCount++;
 852         }
 853     }
 854     ((FontList*)this)->mpSizeAry[nRealCount] = 0;
 855
 856     pDevice->SetMapMode( aOldMapMode );
 857     return mpSizeAry;
 858 }
 859
 860 // -----------------------------------------------------------------------
 861
 862 const long* FontList::GetStdSizeAry()
 863 {
 864     return aStdSizeAry;
 865 }
 866
 867 // =======================================================================
 868
 869 // ---------------------------------
 870 // - FontSizeNames & FsizeNameItem -
 871 // ---------------------------------
 872
 873 struct ImplFSNameItem
 874 {
 875     long                mnSize;
 876     const char* mszUtf8Name;
 877 };
 878
 879 //------------------------------------------------------------------------
 880
 881 static ImplFSNameItem aImplSimplifiedChinese[] =
 882 {
 883     {  50, "\xe5\x85\xab\xe5\x8f\xb7" },
 884     {  55, "\xe4\xb8\x83\xe5\x8f\xb7" },
 885     {  65, "\xe5\xb0\x8f\xe5\x85\xad" },
 886     {  75, "\xe5\x85\xad\xe5\x8f\xb7" },
 887     {  90, "\xe5\xb0\x8f\xe4\xba\x94" },
 888     { 105, "\xe4\xba\x94\xe5\x8f\xb7" },
 889     { 120, "\xe5\xb0\x8f\xe5\x9b\x9b" },
 890     { 140, "\xe5\x9b\x9b\xe5\x8f\xb7" },
 891     { 150, "\xe5\xb0\x8f\xe4\xb8\x89" },
 892     { 160, "\xe4\xb8\x89\xe5\x8f\xb7" },
 893     { 180, "\xe5\xb0\x8f\xe4\xba\x8c" },
 894     { 220, "\xe4\xba\x8c\xe5\x8f\xb7" },
 895     { 240, "\xe5\xb0\x8f\xe4\xb8\x80" },
 896     { 260, "\xe4\xb8\x80\xe5\x8f\xb7" },
 897     { 360, "\xe5\xb0\x8f\xe5\x88\x9d" },
 898     { 420, "\xe5\x88\x9d\xe5\x8f\xb7" }
 899 };
 900
 901 // -----------------------------------------------------------------------
 902
 903 #if 0 // #i89077# disabled by popular request
 904 static ImplFSNameItem aImplTraditionalChinese[] =
 905 {
 906     {  50, "\xe5\x85\xab\xe8\x99\x9f" },
 907     {  55, "\xe4\xb8\x83\xe8\x99\x9f" },
 908     {  65, "\xe5\xb0\x8f\xe5\x85\xad" },
 909     {  75, "\xe5\x85\xad\xe8\x99\x9f" },
 910     {  90, "\xe5\xb0\x8f\xe4\xba\x94" },
 911     { 105, "\xe4\xba\x94\xe8\x99\x9f" },
 912     { 120, "\xe5\xb0\x8f\xe5\x9b\x9b" },
 913     { 140, "\xe5\x9b\x9b\xe8\x99\x9f" },
 914     { 150, "\xe5\xb0\x8f\xe4\xb8\x89" },
 915     { 160, "\xe4\xb8\x89\xe8\x99\x9f" },
 916     { 180, "\xe5\xb0\x8f\xe4\xba\x8c" },
 917     { 220, "\xe4\xba\x8c\xe8\x99\x9f" },
 918     { 240, "\xe5\xb0\x8f\xe4\xb8\x80" },
 919     { 260, "\xe4\xb8\x80\xe8\x99\x9f" },
 920     { 360, "\xe5\xb0\x8f\xe5\x88\x9d" },
 921     { 420, "\xe5\x88\x9d\xe8\x99\x9f" }
 922 };
 923 #endif
 924
 925 //------------------------------------------------------------------------
 926
 927 FontSizeNames::FontSizeNames( LanguageType eLanguage )
 928 {
 929     if ( eLanguage == LANGUAGE_DONTKNOW )
 930         eLanguage = Application::GetSettings().GetUILanguage();
 931     if ( eLanguage == LANGUAGE_SYSTEM )
 932         eLanguage = MsLangId::getSystemUILanguage();
 933
 934     switch( eLanguage )
 935     {
 936         case LANGUAGE_CHINESE:
 937         case LANGUAGE_CHINESE_SIMPLIFIED:
 938             mpArray = aImplSimplifiedChinese;
 939             mnElem = sizeof(aImplSimplifiedChinese) / sizeof(aImplSimplifiedChinese[0]);
 940             break;
 941
 942 #if 0 // #i89077# disabled by popular request
 943         case LANGUAGE_CHINESE_HONGKONG:
 944         case LANGUAGE_CHINESE_SINGAPORE:
 945         case LANGUAGE_CHINESE_MACAU:
 946         case LANGUAGE_CHINESE_TRADITIONAL:
 947             mpArray = aImplTraditionalChinese;
 948             mnElem = sizeof(aImplTraditionalChinese) / sizeof(aImplTraditionalChinese[0]);
 949             break;
 950 #endif
 951
 952         default:
 953             mpArray = NULL;
 954             mnElem = 0;
 955             break;
 956     };
 957 }
 958
 959 //------------------------------------------------------------------------
 960
 961 long FontSizeNames::Name2Size( const String& rName ) const
 962 {
 963     if ( mnElem )
 964     {
 965         ByteString aName( rName, RTL_TEXTENCODING_UTF8 );
 966
 967         // linear search is sufficient for this rare case
 968         for( long i = mnElem; --i >= 0; )
 969             if ( aName == mpArray[i].mszUtf8Name )
 970                 return mpArray[i].mnSize;
 971     }
 972
 973     return 0;
 974 }
 975
 976 //------------------------------------------------------------------------
 977
 978 String FontSizeNames::Size2Name( long nValue ) const
 979 {
 980     String aStr;
 981
 982     // binary search
 983     for( long lower = 0, upper = mnElem - 1; lower <= upper; )
 984     {
 985         long mid = (upper + lower) >> 1;
 986         if ( nValue == mpArray[mid].mnSize )
 987         {
 988             aStr = String( mpArray[mid].mszUtf8Name, RTL_TEXTENCODING_UTF8 );
 989             break;
 990         }
 991         else if ( nValue < mpArray[mid].mnSize )
 992             upper = mid - 1;
 993         else /* ( nValue > mpArray[mid].mnSize ) */
 994             lower = mid + 1;
 995     }
 996
 997     return aStr;
 998 }
 999
1000 //------------------------------------------------------------------------
1001
1002 String FontSizeNames::GetIndexName( ULONG nIndex ) const
1003 {
1004     String aStr;
1005
1006     if ( nIndex < mnElem )
1007         aStr = String( mpArray[nIndex].mszUtf8Name, RTL_TEXTENCODING_UTF8 );
1008
1009     return aStr;
1010 }
1011
1012 //------------------------------------------------------------------------
1013
1014 long FontSizeNames::GetIndexSize( ULONG nIndex ) const
1015 {
1016     if ( nIndex >= mnElem )
1017         return 0;
1018     return mpArray[nIndex].mnSize;
1019 }