/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_svtools.hxx" #define CTRLTOOL_CXX #include #include #include #include #include #include #include #include #include // ======================================================================= // Standard Fontgroessen fuer scalierbare Fonts static long aStdSizeAry[] = { 60, 70, 80, 90, 100, 105, 110, 120, 130, 140, 150, 160, 180, 200, 220, 240, 260, 280, 320, 360, 400, 440, 480, 540, 600, 660, 720, 800, 880, 960, 0 }; // ======================================================================= // ----------------------------- // - class ImplFontListFonInfo - // ----------------------------- class ImplFontListFontInfo : public FontInfo { friend class FontList; private: OutputDevice* mpDevice; ImplFontListFontInfo* mpNext; public: ImplFontListFontInfo( const FontInfo& rInfo, OutputDevice* pDev ) : FontInfo( rInfo ) { mpDevice = pDev; } OutputDevice* GetDevice() const { return mpDevice; } }; // ------------------------------ // - class ImplFontListNameInfo - // ------------------------------ class ImplFontListNameInfo { friend class FontList; private: XubString maSearchName; ImplFontListFontInfo* mpFirst; sal_uInt16 mnType; ImplFontListNameInfo( const XubString& rSearchName ) : maSearchName( rSearchName ) {} const XubString& GetSearchName() const { return maSearchName; } }; // ======================================================================= static StringCompare ImplCompareFontInfo( ImplFontListFontInfo* pInfo1, ImplFontListFontInfo* pInfo2 ) { if ( pInfo1->GetWeight() < pInfo2->GetWeight() ) return COMPARE_LESS; else if ( pInfo1->GetWeight() > pInfo2->GetWeight() ) return COMPARE_GREATER; if ( pInfo1->GetItalic() < pInfo2->GetItalic() ) return COMPARE_LESS; else if ( pInfo1->GetItalic() > pInfo2->GetItalic() ) return COMPARE_GREATER; return pInfo1->GetStyleName().CompareTo( pInfo2->GetStyleName() ); } // ======================================================================= static void ImplMakeSearchString( XubString& rStr ) { rStr.ToLowerAscii(); } // ----------------------------------------------------------------------- static void ImplMakeSearchStringFromName( XubString& rStr ) { // check for features before alternate font separator if (rStr.Search(':') < rStr.Search(';')) rStr = rStr.GetToken( 0, ':' ); else rStr = rStr.GetToken( 0, ';' ); ImplMakeSearchString( rStr ); } // ----------------------------------------------------------------------- ImplFontListNameInfo* FontList::ImplFind( const XubString& rSearchName, sal_uLong* pIndex ) const { // Wenn kein Eintrag in der Liste oder der Eintrag groesser ist als // der Letzte, dann hinten dranhaengen. Wir vergleichen erst mit dem // letzten Eintrag, da die Liste von VCL auch sortiert zurueckkommt // und somit die Wahrscheinlichkeit das hinten angehaengt werden muss // sehr gross ist. StringCompare eComp; sal_uLong nCnt = Count(); if ( !nCnt ) { if ( pIndex ) *pIndex = LIST_APPEND; return NULL; } else { ImplFontListNameInfo* pCmpData = (ImplFontListNameInfo*)List::GetObject( nCnt-1 ); eComp = rSearchName.CompareTo( pCmpData->maSearchName ); if ( eComp == COMPARE_GREATER ) { if ( pIndex ) *pIndex = LIST_APPEND; return NULL; } else if ( eComp == COMPARE_EQUAL ) return pCmpData; } // Fonts in der Liste suchen ImplFontListNameInfo* pCompareData; ImplFontListNameInfo* pFoundData = NULL; sal_uLong nLow = 0; sal_uLong nHigh = nCnt-1; sal_uLong nMid; do { nMid = (nLow + nHigh) / 2; pCompareData = (ImplFontListNameInfo*)List::GetObject( nMid ); eComp = rSearchName.CompareTo( pCompareData->maSearchName ); if ( eComp == COMPARE_LESS ) { if ( !nMid ) break; nHigh = nMid-1; } else { if ( eComp == COMPARE_GREATER ) nLow = nMid + 1; else { pFoundData = pCompareData; break; } } } while ( nLow <= nHigh ); if ( pIndex ) { eComp = rSearchName.CompareTo( pCompareData->maSearchName ); if ( eComp == COMPARE_GREATER ) *pIndex = (nMid+1); else *pIndex = nMid; } return pFoundData; } // ----------------------------------------------------------------------- ImplFontListNameInfo* FontList::ImplFindByName( const XubString& rStr ) const { XubString aSearchName = rStr; ImplMakeSearchStringFromName( aSearchName ); return ImplFind( aSearchName, NULL ); } // ----------------------------------------------------------------------- void FontList::ImplInsertFonts( OutputDevice* pDevice, sal_Bool bAll, sal_Bool bInsertData ) { rtl_TextEncoding eSystemEncoding = gsl_getSystemTextEncoding(); sal_uInt16 nType; if ( pDevice->GetOutDevType() != OUTDEV_PRINTER ) nType = FONTLIST_FONTNAMETYPE_SCREEN; else nType = FONTLIST_FONTNAMETYPE_PRINTER; // Alle Fonts vom Device abfragen int n = pDevice->GetDevFontCount(); sal_uInt16 i; for( i = 0; i < n; i++ ) { FontInfo aFontInfo = pDevice->GetDevFont( i ); // Wenn keine Raster-Schriften angezeigt werden sollen, // dann diese ignorieren if ( !bAll && (aFontInfo.GetType() == TYPE_RASTER) ) continue; XubString aSearchName = aFontInfo.GetName(); ImplFontListNameInfo* pData; sal_uLong nIndex; ImplMakeSearchString( aSearchName ); pData = ImplFind( aSearchName, &nIndex ); if ( !pData ) { if ( bInsertData ) { ImplFontListFontInfo* pNewInfo = new ImplFontListFontInfo( aFontInfo, pDevice ); pData = new ImplFontListNameInfo( aSearchName ); pData->mpFirst = pNewInfo; pNewInfo->mpNext = NULL; pData->mnType = 0; Insert( (void*)pData, nIndex ); } } else { if ( bInsertData ) { sal_Bool bInsert = sal_True; ImplFontListFontInfo* pPrev = NULL; ImplFontListFontInfo* pTemp = pData->mpFirst; ImplFontListFontInfo* pNewInfo = new ImplFontListFontInfo( aFontInfo, pDevice ); while ( pTemp ) { StringCompare eComp = ImplCompareFontInfo( pNewInfo, pTemp ); if ( (eComp == COMPARE_LESS) || (eComp == COMPARE_EQUAL) ) { if ( eComp == COMPARE_EQUAL ) { // Overwrite charset, because charset should match // with the system charset if ( (pTemp->GetCharSet() != eSystemEncoding) && (pNewInfo->GetCharSet() == eSystemEncoding) ) { ImplFontListFontInfo* pTemp2 = pTemp->mpNext; *((FontInfo*)pTemp) = *((FontInfo*)pNewInfo); pTemp->mpNext = pTemp2; } delete pNewInfo; bInsert = sal_False; } break; } pPrev = pTemp; pTemp = pTemp->mpNext; } if ( bInsert ) { pNewInfo->mpNext = pTemp; if ( pPrev ) pPrev->mpNext = pNewInfo; else pData->mpFirst = pNewInfo; } } } if ( pData ) { pData->mnType |= nType; if ( aFontInfo.GetType() != TYPE_RASTER ) pData->mnType |= FONTLIST_FONTNAMETYPE_SCALABLE; } } } // ======================================================================= FontList::FontList( OutputDevice* pDevice, OutputDevice* pDevice2, sal_Bool bAll ) : List( 4096, sal::static_int_cast< sal_uInt16 >(pDevice->GetDevFontCount()), 32 ) { // Variablen initialisieren mpDev = pDevice; mpDev2 = pDevice2; mpSizeAry = NULL; // Stylenamen festlegen maLight = XubString( SvtResId( STR_SVT_STYLE_LIGHT ) ); maLightItalic = XubString( SvtResId( STR_SVT_STYLE_LIGHT_ITALIC ) ); maNormal = XubString( SvtResId( STR_SVT_STYLE_NORMAL ) ); maNormalItalic = XubString( SvtResId( STR_SVT_STYLE_NORMAL_ITALIC ) ); maBold = XubString( SvtResId( STR_SVT_STYLE_BOLD ) ); maBoldItalic = XubString( SvtResId( STR_SVT_STYLE_BOLD_ITALIC ) ); maBlack = XubString( SvtResId( STR_SVT_STYLE_BLACK ) ); maBlackItalic = XubString( SvtResId( STR_SVT_STYLE_BLACK_ITALIC ) ); ImplInsertFonts( pDevice, bAll, sal_True ); // Gegebenenfalls muessen wir mit den Bildschirmfonts vergleichen, // damit dort die eigentlich doppelten auf Equal mappen koennen sal_Bool bCompareWindow = sal_False; if ( !pDevice2 && (pDevice->GetOutDevType() == OUTDEV_PRINTER) ) { bCompareWindow = sal_True; pDevice2 = Application::GetDefaultDevice(); } if ( pDevice2 && (pDevice2->GetOutDevType() != pDevice->GetOutDevType()) ) ImplInsertFonts( pDevice2, bAll, !bCompareWindow ); } // ----------------------------------------------------------------------- FontList::~FontList() { // Gegebenenfalls SizeArray loeschen if ( mpSizeAry ) delete[] mpSizeAry; // FontInfos loeschen ImplFontListNameInfo* pData = (ImplFontListNameInfo*)First(); while ( pData ) { ImplFontListFontInfo* pTemp; ImplFontListFontInfo* pInfo = pData->mpFirst; while ( pInfo ) { pTemp = pInfo->mpNext; delete pInfo; pInfo = pTemp; } ImplFontListNameInfo* pNext = (ImplFontListNameInfo*)Next(); delete pData; pData = pNext; } } // ----------------------------------------------------------------------- FontList* FontList::Clone() const { FontList* pReturn = new FontList( mpDev, mpDev2, GetFontNameCount() == mpDev->GetDevFontCount()); return pReturn; } // ----------------------------------------------------------------------- const XubString& FontList::GetStyleName( FontWeight eWeight, FontItalic eItalic ) const { if ( eWeight > WEIGHT_BOLD ) { if ( eItalic > ITALIC_NONE ) return maBlackItalic; else return maBlack; } else if ( eWeight > WEIGHT_MEDIUM ) { if ( eItalic > ITALIC_NONE ) return maBoldItalic; else return maBold; } else if ( eWeight > WEIGHT_LIGHT ) { if ( eItalic > ITALIC_NONE ) return maNormalItalic; else return maNormal; } else if ( eWeight != WEIGHT_DONTKNOW ) { if ( eItalic > ITALIC_NONE ) return maLightItalic; else return maLight; } else { if ( eItalic > ITALIC_NONE ) return maNormalItalic; else return maNormal; } } // ----------------------------------------------------------------------- XubString FontList::GetStyleName( const FontInfo& rInfo ) const { XubString aStyleName = rInfo.GetStyleName(); FontWeight eWeight = rInfo.GetWeight(); FontItalic eItalic = rInfo.GetItalic(); // Nur wenn kein StyleName gesetzt ist, geben wir einen syntetischen // Namen zurueck if ( !aStyleName.Len() ) aStyleName = GetStyleName( eWeight, eItalic ); else { // Translate StyleName to localized name XubString aCompareStyleName = aStyleName; aCompareStyleName.ToLowerAscii(); aCompareStyleName.EraseAllChars( ' ' ); if ( aCompareStyleName.EqualsAscii( "bold" ) ) aStyleName = maBold; else if ( aCompareStyleName.EqualsAscii( "bolditalic" ) ) aStyleName = maBoldItalic; else if ( aCompareStyleName.EqualsAscii( "italic" ) ) aStyleName = maNormalItalic; else if ( aCompareStyleName.EqualsAscii( "standard" ) ) aStyleName = maNormal; else if ( aCompareStyleName.EqualsAscii( "regular" ) ) aStyleName = maNormal; else if ( aCompareStyleName.EqualsAscii( "medium" ) ) aStyleName = maNormal; else if ( aCompareStyleName.EqualsAscii( "light" ) ) aStyleName = maLight; else if ( aCompareStyleName.EqualsAscii( "lightitalic" ) ) aStyleName = maLightItalic; else if ( aCompareStyleName.EqualsAscii( "black" ) ) aStyleName = maBlack; else if ( aCompareStyleName.EqualsAscii( "blackitalic" ) ) aStyleName = maBlackItalic; // fix up StyleName, because the PS Printer driver from // W2000 returns wrong StyleNames (e.g. Bold instead of Bold Italic // for Helvetica) if ( eItalic > ITALIC_NONE ) { if ( (aStyleName == maNormal) || (aStyleName == maBold) || (aStyleName == maLight) || (aStyleName == maBlack) ) aStyleName = GetStyleName( eWeight, eItalic ); } } return aStyleName; } // ----------------------------------------------------------------------- XubString FontList::GetFontMapText( const FontInfo& rInfo ) const { if ( !rInfo.GetName().Len() ) { XubString aEmptryStr; return aEmptryStr; } // Search Fontname ImplFontListNameInfo* pData = ImplFindByName( rInfo.GetName() ); if ( !pData ) { if ( !maMapNotAvailable.Len() ) ((FontList*)this)->maMapNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_NOTAVAILABLE ) ); return maMapNotAvailable; } // search for synthetic style sal_uInt16 nType = pData->mnType; const XubString& rStyleName = rInfo.GetStyleName(); if ( rStyleName.Len() ) { sal_Bool bNotSynthetic = sal_False; sal_Bool bNoneAvailable = sal_False; FontWeight eWeight = rInfo.GetWeight(); FontItalic eItalic = rInfo.GetItalic(); ImplFontListFontInfo* pFontInfo = pData->mpFirst; while ( pFontInfo ) { if ( (eWeight == pFontInfo->GetWeight()) && (eItalic == pFontInfo->GetItalic()) ) { bNotSynthetic = sal_True; break; } pFontInfo = pFontInfo->mpNext; } if ( bNoneAvailable ) { XubString aEmptryStr; return aEmptryStr; } else if ( !bNotSynthetic ) { if ( !maMapStyleNotAvailable.Len() ) ((FontList*)this)->maMapStyleNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_STYLENOTAVAILABLE ) ); return maMapStyleNotAvailable; } } /* Size not available not implemented yet if ( !(nType & FONTLIST_FONTNAMETYPE_SCALABLE) ) { ... { if ( !maMapSizeNotAvailable.Len() ) ((FontList*)this)->maMapSizeNotAvailable = XubString( SvtResId( STR_SVT_FONTMAP_SIZENOTAVAILABLE ) ); return maMapSizeNotAvailable; } } */ // Only Printer-Font? if ( (nType & (FONTLIST_FONTNAMETYPE_PRINTER | FONTLIST_FONTNAMETYPE_SCREEN)) == FONTLIST_FONTNAMETYPE_PRINTER ) { if ( !maMapPrinterOnly.Len() ) ((FontList*)this)->maMapPrinterOnly = XubString( SvtResId( STR_SVT_FONTMAP_PRINTERONLY ) ); return maMapPrinterOnly; } // Only Screen-Font? else if ( (nType & (FONTLIST_FONTNAMETYPE_PRINTER | FONTLIST_FONTNAMETYPE_SCREEN)) == FONTLIST_FONTNAMETYPE_SCREEN && rInfo.GetType() == TYPE_RASTER ) { if ( !maMapScreenOnly.Len() ) ((FontList*)this)->maMapScreenOnly = XubString( SvtResId( STR_SVT_FONTMAP_SCREENONLY ) ); return maMapScreenOnly; } else { if ( !maMapBoth.Len() ) ((FontList*)this)->maMapBoth = XubString( SvtResId( STR_SVT_FONTMAP_BOTH ) ); return maMapBoth; } } // ----------------------------------------------------------------------- sal_uInt16 FontList::GetFontNameType( const XubString& rFontName ) const { ImplFontListNameInfo* pData = ImplFindByName( rFontName ); if ( pData ) return pData->mnType; else return 0; } // ----------------------------------------------------------------------- FontInfo FontList::Get( const XubString& rName, const XubString& rStyleName ) const { ImplFontListNameInfo* pData = ImplFindByName( rName ); ImplFontListFontInfo* pFontInfo = NULL; ImplFontListFontInfo* pFontNameInfo = NULL; if ( pData ) { ImplFontListFontInfo* pSearchInfo = pData->mpFirst; pFontNameInfo = pSearchInfo; pSearchInfo = pData->mpFirst; while ( pSearchInfo ) { if ( rStyleName.EqualsIgnoreCaseAscii( GetStyleName( *pSearchInfo ) ) ) { pFontInfo = pSearchInfo; break; } pSearchInfo = pSearchInfo->mpNext; } } // Konnten die Daten nicht gefunden werden, dann muessen bestimmte // Attribute nachgebildet werden FontInfo aInfo; if ( !pFontInfo ) { if ( pFontNameInfo ) aInfo = *pFontNameInfo; if ( rStyleName == maNormal ) { aInfo.SetItalic( ITALIC_NONE ); aInfo.SetWeight( WEIGHT_NORMAL ); } else if ( rStyleName == maNormalItalic ) { aInfo.SetItalic( ITALIC_NORMAL ); aInfo.SetWeight( WEIGHT_NORMAL ); } else if ( rStyleName == maBold ) { aInfo.SetItalic( ITALIC_NONE ); aInfo.SetWeight( WEIGHT_BOLD ); } else if ( rStyleName == maBoldItalic ) { aInfo.SetItalic( ITALIC_NORMAL ); aInfo.SetWeight( WEIGHT_BOLD ); } else if ( rStyleName == maLight ) { aInfo.SetItalic( ITALIC_NONE ); aInfo.SetWeight( WEIGHT_LIGHT ); } else if ( rStyleName == maLightItalic ) { aInfo.SetItalic( ITALIC_NORMAL ); aInfo.SetWeight( WEIGHT_LIGHT ); } else if ( rStyleName == maBlack ) { aInfo.SetItalic( ITALIC_NONE ); aInfo.SetWeight( WEIGHT_BLACK ); } else if ( rStyleName == maBlackItalic ) { aInfo.SetItalic( ITALIC_NORMAL ); aInfo.SetWeight( WEIGHT_BLACK ); } else { aInfo.SetItalic( ITALIC_NONE ); aInfo.SetWeight( WEIGHT_DONTKNOW ); } } else aInfo = *pFontInfo; // set Fontname to keep FontAlias aInfo.SetName( rName ); aInfo.SetStyleName( rStyleName ); return aInfo; } // ----------------------------------------------------------------------- FontInfo FontList::Get( const XubString& rName, FontWeight eWeight, FontItalic eItalic ) const { ImplFontListNameInfo* pData = ImplFindByName( rName ); ImplFontListFontInfo* pFontInfo = NULL; ImplFontListFontInfo* pFontNameInfo = NULL; if ( pData ) { ImplFontListFontInfo* pSearchInfo = pData->mpFirst; pFontNameInfo = pSearchInfo; while ( pSearchInfo ) { if ( (eWeight == pSearchInfo->GetWeight()) && (eItalic == pSearchInfo->GetItalic()) ) { pFontInfo = pSearchInfo; break; } pSearchInfo = pSearchInfo->mpNext; } } // Konnten die Daten nicht gefunden werden, dann muessen bestimmte // Attribute nachgebildet werden FontInfo aInfo; if ( !pFontInfo ) { // Falls der Fontname stimmt, uebernehmen wir soviel wie moeglich if ( pFontNameInfo ) { aInfo = *pFontNameInfo; aInfo.SetStyleName( XubString() ); } aInfo.SetWeight( eWeight ); aInfo.SetItalic( eItalic ); } else aInfo = *pFontInfo; // set Fontname to keep FontAlias aInfo.SetName( rName ); return aInfo; } // ----------------------------------------------------------------------- sal_Bool FontList::IsAvailable( const XubString& rName ) const { return (ImplFindByName( rName ) != 0); } // ----------------------------------------------------------------------- const FontInfo& FontList::GetFontName( sal_uInt16 nFont ) const { DBG_ASSERT( nFont < GetFontNameCount(), "FontList::GetFontName(): nFont >= Count" ); ImplFontListNameInfo* pData = (ImplFontListNameInfo*)List::GetObject( nFont ); return *(pData->mpFirst); } // ----------------------------------------------------------------------- sal_uInt16 FontList::GetFontNameType( sal_uInt16 nFont ) const { DBG_ASSERT( nFont < GetFontNameCount(), "FontList::GetFontNameType(): nFont >= Count" ); ImplFontListNameInfo* pData = (ImplFontListNameInfo*)List::GetObject( nFont ); return pData->mnType; } // ----------------------------------------------------------------------- sal_Handle FontList::GetFirstFontInfo( const XubString& rName ) const { ImplFontListNameInfo* pData = ImplFindByName( rName ); if ( !pData ) return (sal_Handle)NULL; else return (sal_Handle)pData->mpFirst; } // ----------------------------------------------------------------------- sal_Handle FontList::GetNextFontInfo( sal_Handle hFontInfo ) const { ImplFontListFontInfo* pInfo = (ImplFontListFontInfo*)(void*)hFontInfo; return (sal_Handle)(pInfo->mpNext); } // ----------------------------------------------------------------------- const FontInfo& FontList::GetFontInfo( sal_Handle hFontInfo ) const { ImplFontListFontInfo* pInfo = (ImplFontListFontInfo*)(void*)hFontInfo; return *pInfo; } // ----------------------------------------------------------------------- const long* FontList::GetSizeAry( const FontInfo& rInfo ) const { // Size-Array vorher loeschen if ( mpSizeAry ) { delete[] ((FontList*)this)->mpSizeAry; ((FontList*)this)->mpSizeAry = NULL; } // Falls kein Name, dann Standardgroessen if ( !rInfo.GetName().Len() ) return aStdSizeAry; // Zuerst nach dem Fontnamen suchen um das Device dann von dem // entsprechenden Font zu nehmen OutputDevice* pDevice = mpDev; ImplFontListNameInfo* pData = ImplFindByName( rInfo.GetName() ); if ( pData ) pDevice = pData->mpFirst->GetDevice(); int nDevSizeCount = pDevice->GetDevFontSizeCount( rInfo ); if ( !nDevSizeCount || (pDevice->GetDevFontSize( rInfo, 0 ).Height() == 0) ) return aStdSizeAry; MapMode aOldMapMode = pDevice->GetMapMode(); MapMode aMap( MAP_10TH_INCH, Point(), Fraction( 1, 72 ), Fraction( 1, 72 ) ); pDevice->SetMapMode( aMap ); sal_uInt16 i; sal_uInt16 nRealCount = 0; long nOldHeight = 0; ((FontList*)this)->mpSizeAry = new long[nDevSizeCount+1]; for ( i = 0; i < nDevSizeCount; i++ ) { Size aSize = pDevice->GetDevFontSize( rInfo, i ); if ( aSize.Height() != nOldHeight ) { nOldHeight = aSize.Height(); ((FontList*)this)->mpSizeAry[nRealCount] = nOldHeight; nRealCount++; } } ((FontList*)this)->mpSizeAry[nRealCount] = 0; pDevice->SetMapMode( aOldMapMode ); return mpSizeAry; } // ----------------------------------------------------------------------- const long* FontList::GetStdSizeAry() { return aStdSizeAry; } // ======================================================================= // --------------------------------- // - FontSizeNames & FsizeNameItem - // --------------------------------- struct ImplFSNameItem { long mnSize; const char* mszUtf8Name; }; //------------------------------------------------------------------------ static ImplFSNameItem aImplSimplifiedChinese[] = { { 50, "\xe5\x85\xab\xe5\x8f\xb7" }, { 55, "\xe4\xb8\x83\xe5\x8f\xb7" }, { 65, "\xe5\xb0\x8f\xe5\x85\xad" }, { 75, "\xe5\x85\xad\xe5\x8f\xb7" }, { 90, "\xe5\xb0\x8f\xe4\xba\x94" }, { 105, "\xe4\xba\x94\xe5\x8f\xb7" }, { 120, "\xe5\xb0\x8f\xe5\x9b\x9b" }, { 140, "\xe5\x9b\x9b\xe5\x8f\xb7" }, { 150, "\xe5\xb0\x8f\xe4\xb8\x89" }, { 160, "\xe4\xb8\x89\xe5\x8f\xb7" }, { 180, "\xe5\xb0\x8f\xe4\xba\x8c" }, { 220, "\xe4\xba\x8c\xe5\x8f\xb7" }, { 240, "\xe5\xb0\x8f\xe4\xb8\x80" }, { 260, "\xe4\xb8\x80\xe5\x8f\xb7" }, { 360, "\xe5\xb0\x8f\xe5\x88\x9d" }, { 420, "\xe5\x88\x9d\xe5\x8f\xb7" } }; // ----------------------------------------------------------------------- #if 0 // #i89077# disabled by popular request static ImplFSNameItem aImplTraditionalChinese[] = { { 50, "\xe5\x85\xab\xe8\x99\x9f" }, { 55, "\xe4\xb8\x83\xe8\x99\x9f" }, { 65, "\xe5\xb0\x8f\xe5\x85\xad" }, { 75, "\xe5\x85\xad\xe8\x99\x9f" }, { 90, "\xe5\xb0\x8f\xe4\xba\x94" }, { 105, "\xe4\xba\x94\xe8\x99\x9f" }, { 120, "\xe5\xb0\x8f\xe5\x9b\x9b" }, { 140, "\xe5\x9b\x9b\xe8\x99\x9f" }, { 150, "\xe5\xb0\x8f\xe4\xb8\x89" }, { 160, "\xe4\xb8\x89\xe8\x99\x9f" }, { 180, "\xe5\xb0\x8f\xe4\xba\x8c" }, { 220, "\xe4\xba\x8c\xe8\x99\x9f" }, { 240, "\xe5\xb0\x8f\xe4\xb8\x80" }, { 260, "\xe4\xb8\x80\xe8\x99\x9f" }, { 360, "\xe5\xb0\x8f\xe5\x88\x9d" }, { 420, "\xe5\x88\x9d\xe8\x99\x9f" } }; #endif //------------------------------------------------------------------------ FontSizeNames::FontSizeNames( LanguageType eLanguage ) { if ( eLanguage == LANGUAGE_DONTKNOW ) eLanguage = Application::GetSettings().GetUILanguage(); if ( eLanguage == LANGUAGE_SYSTEM ) eLanguage = MsLangId::getSystemUILanguage(); switch( eLanguage ) { case LANGUAGE_CHINESE: case LANGUAGE_CHINESE_SIMPLIFIED: mpArray = aImplSimplifiedChinese; mnElem = sizeof(aImplSimplifiedChinese) / sizeof(aImplSimplifiedChinese[0]); break; #if 0 // #i89077# disabled by popular request case LANGUAGE_CHINESE_HONGKONG: case LANGUAGE_CHINESE_SINGAPORE: case LANGUAGE_CHINESE_MACAU: case LANGUAGE_CHINESE_TRADITIONAL: mpArray = aImplTraditionalChinese; mnElem = sizeof(aImplTraditionalChinese) / sizeof(aImplTraditionalChinese[0]); break; #endif default: mpArray = NULL; mnElem = 0; break; }; } //------------------------------------------------------------------------ long FontSizeNames::Name2Size( const String& rName ) const { if ( mnElem ) { ByteString aName( rName, RTL_TEXTENCODING_UTF8 ); // linear search is sufficient for this rare case for( long i = mnElem; --i >= 0; ) if ( aName == mpArray[i].mszUtf8Name ) return mpArray[i].mnSize; } return 0; } //------------------------------------------------------------------------ String FontSizeNames::Size2Name( long nValue ) const { String aStr; // binary search for( long lower = 0, upper = mnElem - 1; lower <= upper; ) { long mid = (upper + lower) >> 1; if ( nValue == mpArray[mid].mnSize ) { aStr = String( mpArray[mid].mszUtf8Name, RTL_TEXTENCODING_UTF8 ); break; } else if ( nValue < mpArray[mid].mnSize ) upper = mid - 1; else /* ( nValue > mpArray[mid].mnSize ) */ lower = mid + 1; } return aStr; } //------------------------------------------------------------------------ String FontSizeNames::GetIndexName( sal_uLong nIndex ) const { String aStr; if ( nIndex < mnElem ) aStr = String( mpArray[nIndex].mszUtf8Name, RTL_TEXTENCODING_UTF8 ); return aStr; } //------------------------------------------------------------------------ long FontSizeNames::GetIndexSize( sal_uLong nIndex ) const { if ( nIndex >= mnElem ) return 0; return mpArray[nIndex].mnSize; }