Author: hdu Date: Mon May 13 09:46:13 2013 New Revision: 1481759 URL: http://svn.apache.org/r1481759 Log: #i122301# the new file impfont.hxx consolidates many internal font helper methods
Added: openoffice/branches/rejuvenate01/main/vcl/source/gdi/impfont.cxx Added: openoffice/branches/rejuvenate01/main/vcl/source/gdi/impfont.cxx URL: http://svn.apache.org/viewvc/openoffice/branches/rejuvenate01/main/vcl/source/gdi/impfont.cxx?rev=1481759&view=auto ============================================================================== --- openoffice/branches/rejuvenate01/main/vcl/source/gdi/impfont.cxx (added) +++ openoffice/branches/rejuvenate01/main/vcl/source/gdi/impfont.cxx Mon May 13 09:46:13 2013 @@ -0,0 +1,871 @@ +/************************************************************** + * + * 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_vcl.hxx" + +#include <vcl/metric.hxx> +#include <outfont.hxx> +#include <impfont.hxx> + +#include <vector> +#include <set> + +// ======================================================================= + +CmapResult::CmapResult( bool bSymbolic, + const sal_UCS4* pRangeCodes, int nRangeCount, + const int* pStartGlyphs, const sal_uInt16* pExtraGlyphIds ) +: mpRangeCodes( pRangeCodes) +, mpStartGlyphs( pStartGlyphs) +, mpGlyphIds( pExtraGlyphIds) +, mnRangeCount( nRangeCount) +, mbSymbolic( bSymbolic) +, mbRecoded( false) +{} + +// ======================================================================= + +ImplFontCharMap::ImplFontCharMap( const CmapResult& rCR ) +: mpRangeCodes( rCR.mpRangeCodes ) +, mpStartGlyphs( rCR.mpStartGlyphs ) +, mpGlyphIds( rCR.mpGlyphIds ) +, mnRangeCount( rCR.mnRangeCount ) +, mnCharCount( 0 ) +, mnRefCount( 1 ) +{ + const sal_UCS4* pRangePtr = mpRangeCodes; + for( int i = mnRangeCount; --i >= 0; pRangePtr += 2 ) + { + sal_UCS4 cFirst = pRangePtr[0]; + sal_UCS4 cLast = pRangePtr[1]; + mnCharCount += cLast - cFirst; + } +} + +static ImplFontCharMap* pDefaultImplFontCharMap = NULL; +static const sal_UCS4 aDefaultUnicodeRanges[] = {0x0020,0xD800, 0xE000,0xFFF0}; +static const sal_UCS4 aDefaultSymbolRanges[] = {0x0020,0x0100, 0xF020,0xF100}; + +// ----------------------------------------------------------------------- + +bool ImplFontCharMap::IsDefaultMap() const +{ + const bool bIsDefault = (mpRangeCodes == aDefaultUnicodeRanges) || (mpRangeCodes == aDefaultSymbolRanges); + return bIsDefault; +} + +// ----------------------------------------------------------------------- + +ImplFontCharMap::~ImplFontCharMap() +{ + if( IsDefaultMap() ) + return; + delete[] mpRangeCodes; + delete[] mpStartGlyphs; + delete[] mpGlyphIds; +} + +// ----------------------------------------------------------------------- + +ImplFontCharMap* ImplFontCharMap::GetDefaultMap( bool bSymbols) +{ + if( pDefaultImplFontCharMap ) + pDefaultImplFontCharMap->AddReference(); + else + { + const sal_UCS4* pRangeCodes = aDefaultUnicodeRanges; + int nCodesCount = sizeof(aDefaultUnicodeRanges) / sizeof(*pRangeCodes); + if( bSymbols ) + { + pRangeCodes = aDefaultSymbolRanges; + nCodesCount = sizeof(aDefaultSymbolRanges) / sizeof(*pRangeCodes); + } + + CmapResult aDefaultCR( bSymbols, pRangeCodes, nCodesCount/2 ); + pDefaultImplFontCharMap = new ImplFontCharMap( aDefaultCR ); + } + + return pDefaultImplFontCharMap; +} + +// ----------------------------------------------------------------------- + +void ImplFontCharMap::AddReference( void) const +{ + ++mnRefCount; +} + +// ----------------------------------------------------------------------- + +void ImplFontCharMap::DeReference( void) const +{ + if( --mnRefCount <= 0 ) + if( this != pDefaultImplFontCharMap ) + delete this; +} + +// ----------------------------------------------------------------------- + +int ImplFontCharMap::GetCharCount() const +{ + return mnCharCount; +} + +// ----------------------------------------------------------------------- + +int ImplFontCharMap::ImplFindRangeIndex( sal_UCS4 cChar ) const +{ + int nLower = 0; + int nMid = mnRangeCount; + int nUpper = 2 * mnRangeCount - 1; + while( nLower < nUpper ) + { + if( cChar >= mpRangeCodes[ nMid ] ) + nLower = nMid; + else + nUpper = nMid - 1; + nMid = (nLower + nUpper + 1) / 2; + } + + return nMid; +} + +// ----------------------------------------------------------------------- + +bool ImplFontCharMap::HasChar( sal_UCS4 cChar ) const +{ + bool bHasChar = false; + + if( mpStartGlyphs == NULL ) { // only the char-ranges are known + const int nRange = ImplFindRangeIndex( cChar ); + if( nRange==0 && cChar<mpRangeCodes[0] ) + return false; + bHasChar = ((nRange & 1) == 0); // inside a range + } else { // glyph mapping is available + const int nGlyphIndex = GetGlyphIndex( cChar ); + bHasChar = (nGlyphIndex != 0); // not the notdef-glyph + } + + return bHasChar; +} + +// ----------------------------------------------------------------------- + +int ImplFontCharMap::GetGlyphIndex( sal_UCS4 cChar ) const +{ + // return -1 if the object doesn't know the glyph ids + if( !mpStartGlyphs ) + return -1; + + // return 0 if the unicode doesn't have a matching glyph + int nRange = ImplFindRangeIndex( cChar ); + // check that we are inside any range + if( (nRange == 0) && (cChar < mpRangeCodes[0]) ) { + // symbol aliasing gives symbol fonts a second chance + const bool bSymbolic = (mpRangeCodes[0]>=0xF000) & (mpRangeCodes[1]<=0xF0FF); + if( !bSymbolic ) + return 0; + // check for symbol aliasing (U+F0xx -> U+00xx) + nRange = ImplFindRangeIndex( cChar | 0xF000 ); + } + // check that we are inside a range + if( (nRange & 1) != 0 ) + return 0; + + // get glyph index directly or indirectly + int nGlyphIndex = cChar - mpRangeCodes[ nRange ]; + const int nStartIndex = mpStartGlyphs[ nRange/2 ]; + if( nStartIndex >= 0 ) { + // the glyph index can be calculated + nGlyphIndex += nStartIndex; + } else { + // the glyphid array has the glyph index + nGlyphIndex = mpGlyphIds[ nGlyphIndex - nStartIndex]; + } + + return nGlyphIndex; +} + +// ----------------------------------------------------------------------- + +// returns the number of chars supported by the font, which +// are inside the unicode range from cMin to cMax (inclusive) +int ImplFontCharMap::CountCharsInRange( sal_UCS4 cMin, sal_UCS4 cMax ) const +{ + int nCount = 0; + + // find and adjust range and char count for cMin + int nRangeMin = ImplFindRangeIndex( cMin ); + if( nRangeMin & 1 ) + ++nRangeMin; + else if( cMin > mpRangeCodes[ nRangeMin ] ) + nCount -= cMin - mpRangeCodes[ nRangeMin ]; + + // find and adjust range and char count for cMax + int nRangeMax = ImplFindRangeIndex( cMax ); + if( nRangeMax & 1 ) + --nRangeMax; + else + nCount -= mpRangeCodes[ nRangeMax+1 ] - cMax - 1; + + // count chars in complete ranges between cMin and cMax + for( int i = nRangeMin; i <= nRangeMax; i+=2 ) + nCount += mpRangeCodes[i+1] - mpRangeCodes[i]; + + return nCount; +} + +// ----------------------------------------------------------------------- + +sal_UCS4 ImplFontCharMap::GetFirstChar() const +{ + return mpRangeCodes[0]; +} + +// ----------------------------------------------------------------------- + +sal_UCS4 ImplFontCharMap::GetLastChar() const +{ + return (mpRangeCodes[ 2*mnRangeCount-1 ] - 1); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 ImplFontCharMap::GetNextChar( sal_UCS4 cChar ) const +{ + if( cChar < GetFirstChar() ) + return GetFirstChar(); + if( cChar >= GetLastChar() ) + return GetLastChar(); + + int nRange = ImplFindRangeIndex( cChar + 1 ); + if( nRange & 1 ) // outside of range? + return mpRangeCodes[ nRange + 1 ]; // => first in next range + return (cChar + 1); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 ImplFontCharMap::GetPrevChar( sal_UCS4 cChar ) const +{ + if( cChar <= GetFirstChar() ) + return GetFirstChar(); + if( cChar > GetLastChar() ) + return GetLastChar(); + + int nRange = ImplFindRangeIndex( cChar - 1 ); + if( nRange & 1 ) // outside a range? + return (mpRangeCodes[ nRange ] - 1); // => last in prev range + return (cChar - 1); +} + +// ----------------------------------------------------------------------- + +int ImplFontCharMap::GetIndexFromChar( sal_UCS4 cChar ) const +{ + // TODO: improve linear walk? + int nCharIndex = 0; + const sal_UCS4* pRange = &mpRangeCodes[0]; + for( int i = 0; i < mnRangeCount; ++i ) + { + sal_UCS4 cFirst = *(pRange++); + sal_UCS4 cLast = *(pRange++); + if( cChar >= cLast ) + nCharIndex += cLast - cFirst; + else if( cChar >= cFirst ) + return nCharIndex + (cChar - cFirst); + else + break; + } + + return -1; +} + +// ----------------------------------------------------------------------- + +sal_UCS4 ImplFontCharMap::GetCharFromIndex( int nCharIndex ) const +{ + // TODO: improve linear walk? + const sal_UCS4* pRange = &mpRangeCodes[0]; + for( int i = 0; i < mnRangeCount; ++i ) + { + sal_UCS4 cFirst = *(pRange++); + sal_UCS4 cLast = *(pRange++); + nCharIndex -= cLast - cFirst; + if( nCharIndex < 0 ) + return (cLast + nCharIndex); + } + + // we can only get here with an out-of-bounds charindex + return mpRangeCodes[0]; +} + +// ======================================================================= + +static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);} +static unsigned Getsal_uInt16( const unsigned char* p ){ return((p[0]<<8) | p[1]);} +static int GetSShort( const unsigned char* p ){ return((static_cast<signed char>(p[0])<<8)|p[1]);} + +// TODO: move CMAP parsing directly into the ImplFontCharMap class +bool ParseCMAP( const unsigned char* pCmap, int nLength, CmapResult& rResult ) +{ + rResult.mpRangeCodes = NULL; + rResult.mpStartGlyphs= NULL; + rResult.mpGlyphIds = NULL; + rResult.mnRangeCount = 0; + rResult.mbRecoded = false; + rResult.mbSymbolic = false; + + // parse the table header and check for validity + if( !pCmap || (nLength < 24) ) + return false; + + if( Getsal_uInt16( pCmap ) != 0x0000 ) // simple check for CMAP corruption + return false; + + int nSubTables = Getsal_uInt16( pCmap + 2 ); + if( (nSubTables <= 0) || (nLength < (24 + 8*nSubTables)) ) + return false; + + // find the most interesting subtable in the CMAP + rtl_TextEncoding eRecodeFrom = RTL_TEXTENCODING_UNICODE; + int nOffset = 0; + int nFormat = -1; + int nBestVal = 0; + for( const unsigned char* p = pCmap + 4; --nSubTables >= 0; p += 8 ) + { + int nPlatform = Getsal_uInt16( p ); + int nEncoding = Getsal_uInt16( p+2 ); + int nPlatformEncoding = (nPlatform << 8) + nEncoding; + + int nValue; + rtl_TextEncoding eTmpEncoding = RTL_TEXTENCODING_UNICODE; + switch( nPlatformEncoding ) + { + case 0x000: nValue = 20; break; // Unicode 1.0 + case 0x001: nValue = 21; break; // Unicode 1.1 + case 0x002: nValue = 22; break; // iso10646_1993 + case 0x003: nValue = 23; break; // UCS-2 + case 0x004: nValue = 24; break; // UCS-4 + case 0x100: nValue = 22; break; // Mac Unicode<2.0 + case 0x103: nValue = 23; break; // Mac Unicode>2.0 + case 0x300: nValue = 5; rResult.mbSymbolic = true; break; // Win Symbol + case 0x301: nValue = 28; break; // Win UCS-2 + case 0x30A: nValue = 29; break; // Win-UCS-4 + case 0x302: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_SHIFT_JIS; break; + case 0x303: nValue = 12; eTmpEncoding = RTL_TEXTENCODING_GB_18030; break; + case 0x304: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_BIG5; break; + case 0x305: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_MS_949; break; + case 0x306: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_MS_1361; break; + default: nValue = 0; break; + } + + if( nValue <= 0 ) // ignore unknown encodings + continue; + + int nTmpOffset = GetUInt( p+4 ); + int nTmpFormat = Getsal_uInt16( pCmap + nTmpOffset ); + if( nTmpFormat == 12 ) // 32bit code -> glyph map format + nValue += 3; + else if( nTmpFormat != 4 ) // 16bit code -> glyph map format + continue; // ignore other formats + + if( nBestVal < nValue ) + { + nBestVal = nValue; + nOffset = nTmpOffset; + nFormat = nTmpFormat; + eRecodeFrom = eTmpEncoding; + } + } + + // parse the best CMAP subtable + int nRangeCount = 0; + sal_UCS4* pCodePairs = NULL; + int* pStartGlyphs = NULL; + + typedef std::vector<sal_uInt16> U16Vector; + U16Vector aGlyphIdArray; + aGlyphIdArray.reserve( 0x1000 ); + aGlyphIdArray.push_back( 0 ); + + // format 4, the most common 16bit char mapping table + if( (nFormat == 4) && ((nOffset+16) < nLength) ) + { + int nSegCountX2 = Getsal_uInt16( pCmap + nOffset + 6 ); + nRangeCount = nSegCountX2/2 - 1; + pCodePairs = new sal_UCS4[ nRangeCount * 2 ]; + pStartGlyphs = new int[ nRangeCount ]; + const unsigned char* pLimitBase = pCmap + nOffset + 14; + const unsigned char* pBeginBase = pLimitBase + nSegCountX2 + 2; + const unsigned char* pDeltaBase = pBeginBase + nSegCountX2; + const unsigned char* pOffsetBase = pDeltaBase + nSegCountX2; + sal_UCS4* pCP = pCodePairs; + for( int i = 0; i < nRangeCount; ++i ) + { + const sal_UCS4 cMinChar = Getsal_uInt16( pBeginBase + 2*i ); + const sal_UCS4 cMaxChar = Getsal_uInt16( pLimitBase + 2*i ); + const int nGlyphDelta = GetSShort( pDeltaBase + 2*i ); + const int nRangeOffset = Getsal_uInt16( pOffsetBase + 2*i ); + if( cMinChar > cMaxChar ) // no sane font should trigger this + break; + if( cMaxChar == 0xFFFF ) + break; + *(pCP++) = cMinChar; + *(pCP++) = cMaxChar + 1; + if( !nRangeOffset ) { + // glyphid can be calculated directly + pStartGlyphs[i] = (cMinChar + nGlyphDelta) & 0xFFFF; + } else { + // update the glyphid-array with the glyphs in this range + pStartGlyphs[i] = -(int)aGlyphIdArray.size(); + const unsigned char* pGlyphIdPtr = pOffsetBase + 2*i + nRangeOffset; + for( sal_UCS4 c = cMinChar; c <= cMaxChar; ++c, pGlyphIdPtr+=2 ) { + const int nGlyphIndex = Getsal_uInt16( pGlyphIdPtr ) + nGlyphDelta; + aGlyphIdArray.push_back( static_cast<sal_uInt16>(nGlyphIndex) ); + } + } + } + nRangeCount = (pCP - pCodePairs) / 2; + } + // format 12, the most common 32bit char mapping table + else if( (nFormat == 12) && ((nOffset+16) < nLength) ) + { + nRangeCount = GetUInt( pCmap + nOffset + 12 ); + pCodePairs = new sal_UCS4[ nRangeCount * 2 ]; + pStartGlyphs = new int[ nRangeCount ]; + const unsigned char* pGroup = pCmap + nOffset + 16; + sal_UCS4* pCP = pCodePairs; + for( int i = 0; i < nRangeCount; ++i ) + { + sal_UCS4 cMinChar = GetUInt( pGroup + 0 ); + sal_UCS4 cMaxChar = GetUInt( pGroup + 4 ); + int nGlyphId = GetUInt( pGroup + 8 ); + pGroup += 12; +#if 0 // TODO: remove unicode baseplane clipping for UCS-4 support + if( cMinChar > 0xFFFF ) + continue; + if( cMaxChar > 0xFFFF ) + cMaxChar = 0xFFFF; +#else + if( cMinChar > cMaxChar ) // no sane font should trigger this + break; +#endif + *(pCP++) = cMinChar; + *(pCP++) = cMaxChar + 1; + pStartGlyphs[i] = nGlyphId; + } + nRangeCount = (pCP - pCodePairs) / 2; + } + + // check if any subtable resulted in something usable + if( nRangeCount <= 0 ) + { + delete[] pCodePairs; + delete[] pStartGlyphs; + + // even when no CMAP is available we know it for symbol fonts + if( rResult.mbSymbolic ) + { + pCodePairs = new sal_UCS4[4]; + pCodePairs[0] = 0x0020; // aliased symbols + pCodePairs[1] = 0x0100; + pCodePairs[2] = 0xF020; // original symbols + pCodePairs[3] = 0xF100; + rResult.mpRangeCodes = pCodePairs; + rResult.mnRangeCount = 2; + return true; + } + + return false; + } + + // recode the code ranges to their unicode encoded ranges if needed + rtl_TextToUnicodeConverter aConverter = NULL; + rtl_UnicodeToTextContext aCvtContext = NULL; + + rResult.mbRecoded = ( eRecodeFrom != RTL_TEXTENCODING_UNICODE ); + if( rResult.mbRecoded ) + { + aConverter = rtl_createTextToUnicodeConverter( eRecodeFrom ); + aCvtContext = rtl_createTextToUnicodeContext( aConverter ); + } + + if( aConverter && aCvtContext ) + { + // determine the set of supported unicodes from encoded ranges + typedef std::set<sal_UCS4> Ucs4Set; + Ucs4Set aSupportedUnicodes; + + static const int NINSIZE = 64; + static const int NOUTSIZE = 64; + sal_Char cCharsInp[ NINSIZE ]; + sal_Unicode cCharsOut[ NOUTSIZE ]; + sal_UCS4* pCP = pCodePairs; + for( int i = 0; i < nRangeCount; ++i ) + { + sal_UCS4 cMin = *(pCP++); + sal_UCS4 cEnd = *(pCP++); + while( cMin < cEnd ) + { + int j = 0; + for(; (cMin < cEnd) && (j < NINSIZE); ++cMin ) + { + if( cMin >= 0x0100 ) + cCharsInp[ j++ ] = static_cast<sal_Char>(cMin >> 8); + if( (cMin >= 0x0100) || (cMin < 0x00A0) ) + cCharsInp[ j++ ] = static_cast<sal_Char>(cMin); + } + + sal_uInt32 nCvtInfo; + sal_Size nSrcCvtBytes; + int nOutLen = rtl_convertTextToUnicode( + aConverter, aCvtContext, + cCharsInp, j, cCharsOut, NOUTSIZE, + RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE + | RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE, + &nCvtInfo, &nSrcCvtBytes ); + + for( j = 0; j < nOutLen; ++j ) + aSupportedUnicodes.insert( cCharsOut[j] ); + } + } + + rtl_destroyTextToUnicodeConverter( aCvtContext ); + rtl_destroyTextToUnicodeConverter( aConverter ); + + // convert the set of supported unicodes to ranges + typedef std::vector<sal_UCS4> Ucs4Vector; + Ucs4Vector aSupportedRanges; + + Ucs4Set::const_iterator itChar = aSupportedUnicodes.begin(); + for(; itChar != aSupportedUnicodes.end(); ++itChar ) + { + if( aSupportedRanges.empty() + || (aSupportedRanges.back() != *itChar) ) + { + // add new range beginning with current unicode + aSupportedRanges.push_back( *itChar ); + aSupportedRanges.push_back( 0 ); + } + + // extend existing range to include current unicode + aSupportedRanges.back() = *itChar + 1; + } + + // glyph mapping for non-unicode fonts not implemented + delete[] pStartGlyphs; + pStartGlyphs = NULL; + aGlyphIdArray.clear(); + + // make a pCodePairs array using the vector from above + delete[] pCodePairs; + nRangeCount = aSupportedRanges.size() / 2; + if( nRangeCount <= 0 ) + return false; + pCodePairs = new sal_UCS4[ nRangeCount * 2 ]; + Ucs4Vector::const_iterator itInt = aSupportedRanges.begin(); + for( pCP = pCodePairs; itInt != aSupportedRanges.end(); ++itInt ) + *(pCP++) = *itInt; + } + + // prepare the glyphid-array if needed + // TODO: merge ranges if they are close enough? + sal_uInt16* pGlyphIds = NULL; + if( !aGlyphIdArray.empty()) + { + pGlyphIds = new sal_uInt16[ aGlyphIdArray.size() ]; + sal_uInt16* pOut = pGlyphIds; + U16Vector::const_iterator it = aGlyphIdArray.begin(); + while( it != aGlyphIdArray.end() ) + *(pOut++) = *(it++); + } + + // update the result struct + rResult.mpRangeCodes = pCodePairs; + rResult.mpStartGlyphs = pStartGlyphs; + rResult.mnRangeCount = nRangeCount; + rResult.mpGlyphIds = pGlyphIds; + return true; +} + +// ======================================================================= + +FontCharMap::FontCharMap() +: mpImpl( ImplFontCharMap::GetDefaultMap() ) +{} + +// ----------------------------------------------------------------------- + +FontCharMap::~FontCharMap() +{ + mpImpl->DeReference(); + mpImpl = NULL; +} + +// ----------------------------------------------------------------------- + +int FontCharMap::GetCharCount() const +{ + return mpImpl->GetCharCount(); +} + +// ----------------------------------------------------------------------- + +int FontCharMap::CountCharsInRange( sal_UCS4 cMin, sal_UCS4 cMax ) const +{ + return mpImpl->CountCharsInRange( cMin, cMax ); +} + +// ----------------------------------------------------------------------- + +void FontCharMap::Reset( const ImplFontCharMap* pNewMap ) +{ + if( pNewMap == NULL ) + { + mpImpl->DeReference(); + mpImpl = ImplFontCharMap::GetDefaultMap(); + } + else if( pNewMap != mpImpl ) + { + mpImpl->DeReference(); + mpImpl = pNewMap; + mpImpl->AddReference(); + } +} + +// ----------------------------------------------------------------------- + +bool FontCharMap::IsDefaultMap() const +{ + return mpImpl->IsDefaultMap(); +} + +// ----------------------------------------------------------------------- + +bool FontCharMap::HasChar( sal_UCS4 cChar ) const +{ + return mpImpl->HasChar( cChar ); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 FontCharMap::GetFirstChar() const +{ + return mpImpl->GetFirstChar(); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 FontCharMap::GetLastChar() const +{ + return mpImpl->GetLastChar(); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 FontCharMap::GetNextChar( sal_UCS4 cChar ) const +{ + return mpImpl->GetNextChar( cChar ); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 FontCharMap::GetPrevChar( sal_UCS4 cChar ) const +{ + return mpImpl->GetPrevChar( cChar ); +} + +// ----------------------------------------------------------------------- + +int FontCharMap::GetIndexFromChar( sal_UCS4 cChar ) const +{ + return mpImpl->GetIndexFromChar( cChar ); +} + +// ----------------------------------------------------------------------- + +sal_UCS4 FontCharMap::GetCharFromIndex( int nIndex ) const +{ + return mpImpl->GetCharFromIndex( nIndex ); +} + +// ======================================================================= + +// on some systems we have to get the font attributes from the name table +// since neither head's macStyle nor OS/2's panose are easily available +// during font enumeration. macStyle bits would be not sufficient anyway +// and SFNT fonts on Mac usually do not contain an OS/2 table. +void UpdateAttributesFromPSName( const String& rPSName, ImplDevFontAttributes& rDFA ) +{ + ByteString aPSName( rPSName, RTL_TEXTENCODING_UTF8 ); + aPSName.ToLowerAscii(); + + // TODO: use a multi-string ignore-case matcher once it becomes available + if( (aPSName.Search("regular") != STRING_NOTFOUND) + || (aPSName.Search("normal") != STRING_NOTFOUND) + || (aPSName.Search("roman") != STRING_NOTFOUND) + || (aPSName.Search("medium") != STRING_NOTFOUND) + || (aPSName.Search("plain") != STRING_NOTFOUND) + || (aPSName.Search("standard") != STRING_NOTFOUND) + || (aPSName.Search("std") != STRING_NOTFOUND) ) + { + rDFA.meWidthType = WIDTH_NORMAL; + rDFA.meWeight = WEIGHT_NORMAL; + rDFA.meItalic = ITALIC_NONE; + } + + // heuristics for font weight + if (aPSName.Search("extrablack") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_BLACK; + else if (aPSName.Search("black") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_BLACK; +#if 1 + else if (aPSName.Search("book") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_NORMAL; +#endif + else if( (aPSName.Search("semibold") != STRING_NOTFOUND) + || (aPSName.Search("smbd") != STRING_NOTFOUND)) + rDFA.meWeight = WEIGHT_SEMIBOLD; + else if( aPSName.Search("ultrabold") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_ULTRABOLD; + else if( aPSName.Search("extrabold") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_BLACK; + else if( (aPSName.Search("bold") != STRING_NOTFOUND) + || (aPSName.Search("-bd") != STRING_NOTFOUND)) + rDFA.meWeight = WEIGHT_BOLD; + else if( aPSName.Search("extralight") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_ULTRALIGHT; + else if( aPSName.Search("ultralight") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_ULTRALIGHT; + else if( aPSName.Search("light") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_LIGHT; + else if( aPSName.Search("thin") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_THIN; + else if( aPSName.Search("-w3") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_LIGHT; + else if( aPSName.Search("-w4") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_SEMILIGHT; + else if( aPSName.Search("-w5") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_NORMAL; + else if( aPSName.Search("-w6") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_SEMIBOLD; + else if( aPSName.Search("-w7") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_BOLD; + else if( aPSName.Search("-w8") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_ULTRABOLD; + else if( aPSName.Search("-w9") != STRING_NOTFOUND) + rDFA.meWeight = WEIGHT_BLACK; + + // heuristics for font slant + if( (aPSName.Search("italic") != STRING_NOTFOUND) + || (aPSName.Search(" ital") != STRING_NOTFOUND) + || (aPSName.Search("cursive") != STRING_NOTFOUND) + || (aPSName.Search("-it") != STRING_NOTFOUND) + || (aPSName.Search("lightit") != STRING_NOTFOUND) + || (aPSName.Search("mediumit") != STRING_NOTFOUND) + || (aPSName.Search("boldit") != STRING_NOTFOUND) + || (aPSName.Search("cnit") != STRING_NOTFOUND) + || (aPSName.Search("bdcn") != STRING_NOTFOUND) + || (aPSName.Search("bdit") != STRING_NOTFOUND) + || (aPSName.Search("condit") != STRING_NOTFOUND) + || (aPSName.Search("bookit") != STRING_NOTFOUND) + || (aPSName.Search("blackit") != STRING_NOTFOUND) ) + rDFA.meItalic = ITALIC_NORMAL; + if( (aPSName.Search("oblique") != STRING_NOTFOUND) + || (aPSName.Search("inclined") != STRING_NOTFOUND) + || (aPSName.Search("slanted") != STRING_NOTFOUND) ) + rDFA.meItalic = ITALIC_OBLIQUE; + + // heuristics for font width + if( (aPSName.Search("condensed") != STRING_NOTFOUND) + || (aPSName.Search("-cond") != STRING_NOTFOUND) + || (aPSName.Search("boldcond") != STRING_NOTFOUND) + || (aPSName.Search("boldcn") != STRING_NOTFOUND) + || (aPSName.Search("cnit") != STRING_NOTFOUND) ) + rDFA.meWidthType = WIDTH_CONDENSED; + else if (aPSName.Search("narrow") != STRING_NOTFOUND) + rDFA.meWidthType = WIDTH_SEMI_CONDENSED; + else if (aPSName.Search("expanded") != STRING_NOTFOUND) + rDFA.meWidthType = WIDTH_EXPANDED; + else if (aPSName.Search("wide") != STRING_NOTFOUND) + rDFA.meWidthType = WIDTH_EXPANDED; + + // heuristics for font pitch + if( (aPSName.Search("mono") != STRING_NOTFOUND) + || (aPSName.Search("courier") != STRING_NOTFOUND) + || (aPSName.Search("monaco") != STRING_NOTFOUND) + || (aPSName.Search("typewriter") != STRING_NOTFOUND) ) + rDFA.mePitch = PITCH_FIXED; + + // heuristics for font family type + if( (aPSName.Search("script") != STRING_NOTFOUND) + || (aPSName.Search("chancery") != STRING_NOTFOUND) + || (aPSName.Search("zapfino") != STRING_NOTFOUND)) + rDFA.meFamily = FAMILY_SCRIPT; + else if( (aPSName.Search("comic") != STRING_NOTFOUND) + || (aPSName.Search("outline") != STRING_NOTFOUND) + || (aPSName.Search("pinpoint") != STRING_NOTFOUND) ) + rDFA.meFamily = FAMILY_DECORATIVE; + else if( (aPSName.Search("sans") != STRING_NOTFOUND) + || (aPSName.Search("arial") != STRING_NOTFOUND) ) + rDFA.meFamily = FAMILY_SWISS; + else if( (aPSName.Search("roman") != STRING_NOTFOUND) + || (aPSName.Search("times") != STRING_NOTFOUND) ) + rDFA.meFamily = FAMILY_ROMAN; + + // heuristics for codepoint semantic + if( (aPSName.Search("symbol") != STRING_NOTFOUND) + || (aPSName.Search("dings") != STRING_NOTFOUND) + || (aPSName.Search("dingbats") != STRING_NOTFOUND) + || (aPSName.Search("braille") != STRING_NOTFOUND) + || (aPSName.Search("ornaments") != STRING_NOTFOUND) + || (aPSName.Search("embellishments") != STRING_NOTFOUND) ) + rDFA.mbSymbolFlag = true; + + // #i100020# special heuristic for names with single-char styles + // NOTE: we are checking name that hasn't been lower-cased + if( rPSName.Len() > 3 ) + { + int i = rPSName.Len(); + sal_Unicode c = rPSName.GetChar( --i ); + if( c == 'C' ) { // "capitals" + rDFA.meFamily = FAMILY_DECORATIVE; + c = rPSName.GetChar( --i ); + } + if( c == 'O' ) { // CFF-based OpenType + c = rPSName.GetChar( --i ); + } + if( c == 'I' ) { // "italic" + rDFA.meItalic = ITALIC_NORMAL; + c = rPSName.GetChar( --i ); + } + if( c == 'B' ) // "bold" + rDFA.meWeight = WEIGHT_BOLD; + if( c == 'C' ) // "capitals" + rDFA.meFamily = FAMILY_DECORATIVE; + // TODO: check that all single-char styles have been resolved? + } +} + +// ======================================================================= +