| /************************************************************** |
| * |
| * 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 <string.h> |
| |
| #include <tools/debug.hxx> |
| #include <i18npool/mslangid.hxx> |
| #include <vcl/window.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <svtools/svtools.hrc> |
| #include <svtools/svtdata.hxx> |
| #include <svtools/ctrltool.hxx> |
| |
| // ======================================================================= |
| |
| // 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; |
| } |
