| /************************************************************** |
| * |
| * 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? |
| } |
| } |
| |
| // ======================================================================= |
| |
