LCOV - code coverage report
Current view: top level - libreoffice/vcl/source/gdi - metric.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 238 426 55.9 %
Date: 2012-12-27 Functions: 36 56 64.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <impfont.hxx>
      22             : #include <vcl/metric.hxx>
      23             : 
      24             : #include <vector>
      25             : #include <set>
      26             : 
      27             : #include <cstdio>
      28             : 
      29             : // =======================================================================
      30             : 
      31       94915 : ImplFontMetric::ImplFontMetric()
      32             : :   mnAscent( 0 ),
      33             :     mnDescent( 0 ),
      34             :     mnIntLeading( 0 ),
      35             :     mnExtLeading( 0 ),
      36             :     mnLineHeight( 0 ),
      37             :     mnSlant( 0 ),
      38             :     mnMiscFlags( 0 ),
      39       94915 :     mnRefCount( 1 )
      40       94915 : {}
      41             : 
      42             : // -----------------------------------------------------------------------
      43             : 
      44       49940 : inline void ImplFontMetric::AddReference()
      45             : {
      46             :     // TODO: disable refcounting on the default maps?
      47       49940 :     ++mnRefCount;
      48       49940 : }
      49             : 
      50             : // -----------------------------------------------------------------------
      51             : 
      52      124175 : inline void ImplFontMetric::DeReference()
      53             : {
      54             :     // TODO: disable refcounting on the default maps?
      55      124175 :     if( --mnRefCount <= 0 )
      56       74235 :         delete this;
      57      124175 : }
      58             : 
      59             : // -----------------------------------------------------------------------
      60             : 
      61           0 : bool ImplFontMetric::operator==( const ImplFontMetric& r ) const
      62             : {
      63           0 :     if( mnMiscFlags  != r.mnMiscFlags )
      64           0 :         return false;
      65           0 :     if( mnAscent     != r.mnAscent )
      66           0 :         return false;
      67           0 :     if( mnDescent    != r.mnDescent )
      68           0 :         return false;
      69           0 :     if( mnIntLeading != r.mnIntLeading )
      70           0 :         return false;
      71           0 :     if( mnExtLeading != r.mnExtLeading )
      72           0 :         return false;
      73           0 :     if( mnSlant      != r.mnSlant )
      74           0 :         return false;
      75             : 
      76           0 :     return true;
      77             : }
      78             : 
      79             : // =======================================================================
      80             : 
      81       94915 : FontInfo::FontInfo()
      82       94915 : :   mpImplMetric( new ImplFontMetric )
      83       94915 : {}
      84             : 
      85             : // -----------------------------------------------------------------------
      86             : 
      87       49830 : FontInfo::FontInfo( const FontInfo& rInfo )
      88       49830 : :  Font( rInfo )
      89             : {
      90       49830 :     mpImplMetric = rInfo.mpImplMetric;
      91       49830 :     mpImplMetric->AddReference();
      92       49830 : }
      93             : 
      94             : // -----------------------------------------------------------------------
      95             : 
      96      248130 : FontInfo::~FontInfo()
      97             : {
      98      124065 :     mpImplMetric->DeReference();
      99      124065 : }
     100             : 
     101             : // -----------------------------------------------------------------------
     102             : 
     103         110 : FontInfo& FontInfo::operator=( const FontInfo& rInfo )
     104             : {
     105         110 :     Font::operator=( rInfo );
     106             : 
     107         110 :     if( mpImplMetric != rInfo.mpImplMetric )
     108             :     {
     109         110 :         mpImplMetric->DeReference();
     110         110 :         mpImplMetric = rInfo.mpImplMetric;
     111         110 :         mpImplMetric->AddReference();
     112             :     }
     113             : 
     114         110 :     return *this;
     115             : }
     116             : 
     117             : // -----------------------------------------------------------------------
     118             : 
     119           0 : sal_Bool FontInfo::operator==( const FontInfo& rInfo ) const
     120             : {
     121           0 :     if( !Font::operator==( rInfo ) )
     122           0 :         return sal_False;
     123           0 :     if( mpImplMetric == rInfo.mpImplMetric )
     124           0 :         return sal_True;
     125           0 :     if( *mpImplMetric == *rInfo.mpImplMetric  )
     126           0 :         return sal_True;
     127           0 :     return sal_False;
     128             : }
     129             : 
     130             : // -----------------------------------------------------------------------
     131             : 
     132       15510 : FontType FontInfo::GetType() const
     133             : {
     134       15510 :     return (mpImplMetric->IsScalable() ? TYPE_SCALABLE : TYPE_RASTER);
     135             : }
     136             : 
     137           0 : FontMetric::FontMetric( const FontMetric& rMetric )
     138           0 : :    FontInfo( rMetric )
     139           0 : {}
     140             : 
     141             : // -----------------------------------------------------------------------
     142             : 
     143       43991 : long FontMetric::GetAscent() const
     144             : {
     145       43991 :     return mpImplMetric->GetAscent();
     146             : }
     147             : 
     148             : // -----------------------------------------------------------------------
     149             : 
     150       29485 : long FontMetric::GetDescent() const
     151             : {
     152       29485 :     return mpImplMetric->GetDescent();
     153             : }
     154             : 
     155             : // -----------------------------------------------------------------------
     156             : 
     157       50359 : long FontMetric::GetIntLeading() const
     158             : {
     159       50359 :     return mpImplMetric->GetIntLeading();
     160             : }
     161             : 
     162             : // -----------------------------------------------------------------------
     163             : 
     164         707 : long FontMetric::GetExtLeading() const
     165             : {
     166         707 :     return mpImplMetric->GetExtLeading();
     167             : }
     168             : 
     169             : // -----------------------------------------------------------------------
     170             : 
     171           0 : long FontMetric::GetLineHeight() const
     172             : {
     173           0 :     return mpImplMetric->GetLineHeight();
     174             : }
     175             : 
     176             : // -----------------------------------------------------------------------
     177             : 
     178           0 : long FontMetric::GetSlant() const
     179             : {
     180           0 :     return mpImplMetric->GetSlant();
     181             : }
     182             : 
     183             : // -----------------------------------------------------------------------
     184             : 
     185           1 : FontMetric& FontMetric::operator =( const FontMetric& rMetric )
     186             : {
     187           1 :     FontInfo::operator=( rMetric );
     188           1 :     return *this;
     189             : }
     190             : 
     191             : // -----------------------------------------------------------------------
     192             : 
     193           0 : sal_Bool FontMetric::operator==( const FontMetric& rMetric ) const
     194             : {
     195           0 :     return FontInfo::operator==( rMetric );
     196             : }
     197             : 
     198             : // =======================================================================
     199             : 
     200          33 : CmapResult::CmapResult( bool bSymbolic,
     201             :     const sal_uInt32* pRangeCodes, int nRangeCount,
     202             :     const int* pStartGlyphs, const sal_uInt16* pExtraGlyphIds )
     203             : :   mpRangeCodes( pRangeCodes)
     204             : ,   mpStartGlyphs( pStartGlyphs)
     205             : ,   mpGlyphIds( pExtraGlyphIds)
     206             : ,   mnRangeCount( nRangeCount)
     207             : ,   mbSymbolic( bSymbolic)
     208          33 : ,   mbRecoded( false)
     209          33 : {}
     210             : 
     211             : // =======================================================================
     212             : 
     213          33 : ImplFontCharMap::ImplFontCharMap( const CmapResult& rCR )
     214             : :   mpRangeCodes( rCR.mpRangeCodes )
     215             : ,   mpStartGlyphs( rCR.mpStartGlyphs )
     216             : ,   mpGlyphIds( rCR.mpGlyphIds )
     217             : ,   mnRangeCount( rCR.mnRangeCount )
     218             : ,   mnCharCount( 0 )
     219          33 : ,   mnRefCount( 0 )
     220             : {
     221          33 :     const sal_uInt32* pRangePtr = mpRangeCodes;
     222        3874 :     for( int i = mnRangeCount; --i >= 0; pRangePtr += 2 )
     223             :     {
     224        3841 :         sal_uInt32 cFirst = pRangePtr[0];
     225        3841 :         sal_uInt32 cLast  = pRangePtr[1];
     226        3841 :         mnCharCount += cLast - cFirst;
     227             :     }
     228          33 : }
     229             : 
     230             : static ImplFontCharMap* pDefaultUnicodeImplFontCharMap = NULL;
     231             : static ImplFontCharMap* pDefaultSymbolImplFontCharMap = NULL;
     232             : static const sal_uInt32 aDefaultUnicodeRanges[] = {0x0020,0xD800, 0xE000,0xFFF0};
     233             : static const sal_uInt32 aDefaultSymbolRanges[] = {0x0020,0x0100, 0xF020,0xF100};
     234             : 
     235             : // -----------------------------------------------------------------------
     236             : 
     237        2863 : bool ImplFontCharMap::IsDefaultMap() const
     238             : {
     239        2863 :     const bool bIsDefault = (mpRangeCodes == aDefaultUnicodeRanges) || (mpRangeCodes == aDefaultSymbolRanges);
     240        2863 :     return bIsDefault;
     241             : }
     242             : 
     243             : // -----------------------------------------------------------------------
     244             : 
     245          44 : ImplFontCharMap::~ImplFontCharMap()
     246             : {
     247          22 :     if( IsDefaultMap() )
     248           0 :         return;
     249          22 :     delete[] mpRangeCodes;
     250          22 :     delete[] mpStartGlyphs;
     251          22 :     delete[] mpGlyphIds;
     252          44 :  }
     253             : 
     254             : // -----------------------------------------------------------------------
     255             : 
     256             : namespace
     257             : {
     258        5682 :     ImplFontCharMap *GetDefaultUnicodeMap()
     259             :     {
     260        5682 :         if( !pDefaultUnicodeImplFontCharMap )
     261             :         {
     262          11 :             const sal_uInt32* pRangeCodes = aDefaultUnicodeRanges;
     263          11 :             int nCodesCount = sizeof(aDefaultUnicodeRanges) / sizeof(*pRangeCodes);
     264          11 :             CmapResult aDefaultCR( false, pRangeCodes, nCodesCount/2 );
     265          11 :             pDefaultUnicodeImplFontCharMap = new ImplFontCharMap( aDefaultCR );
     266          11 :             pDefaultUnicodeImplFontCharMap->AddReference();
     267             :         }
     268             : 
     269        5682 :         return pDefaultUnicodeImplFontCharMap;
     270             :     }
     271             : 
     272           0 :     ImplFontCharMap *GetDefaultSymbolMap()
     273             :     {
     274           0 :         if( !pDefaultSymbolImplFontCharMap )
     275             :         {
     276           0 :             const sal_uInt32* pRangeCodes = aDefaultSymbolRanges;
     277           0 :             int nCodesCount = sizeof(aDefaultSymbolRanges) / sizeof(*pRangeCodes);
     278           0 :             CmapResult aDefaultCR( true, pRangeCodes, nCodesCount/2 );
     279           0 :             pDefaultSymbolImplFontCharMap = new ImplFontCharMap( aDefaultCR );
     280           0 :             pDefaultSymbolImplFontCharMap->AddReference();
     281             :         }
     282             : 
     283           0 :         return pDefaultSymbolImplFontCharMap;
     284             :     }
     285             : }
     286             : 
     287        5682 : ImplFontCharMap* ImplFontCharMap::GetDefaultMap( bool bSymbols)
     288             : {
     289        5682 :     return bSymbols ? GetDefaultSymbolMap() : GetDefaultUnicodeMap();
     290             : }
     291             : 
     292             : // -----------------------------------------------------------------------
     293             : 
     294        8556 : void ImplFontCharMap::AddReference( void ) const
     295             : {
     296             :     // TODO: disable refcounting on the default maps?
     297        8556 :     ++mnRefCount;
     298        8556 : }
     299             : 
     300             : // -----------------------------------------------------------------------
     301             : 
     302        8545 : void ImplFontCharMap::DeReference( void ) const
     303             : {
     304        8545 :     if( --mnRefCount <= 0 )
     305          22 :         if( (this != pDefaultUnicodeImplFontCharMap) && (this != pDefaultSymbolImplFontCharMap) )
     306          22 :             delete this;
     307        8545 : }
     308             : 
     309             : // -----------------------------------------------------------------------
     310             : 
     311           0 : int ImplFontCharMap::GetCharCount() const
     312             : {
     313           0 :     return mnCharCount;
     314             : }
     315             : 
     316             : // -----------------------------------------------------------------------
     317             : 
     318        9528 : int ImplFontCharMap::ImplFindRangeIndex( sal_uInt32 cChar ) const
     319             : {
     320        9528 :     int nLower = 0;
     321        9528 :     int nMid   = mnRangeCount;
     322        9528 :     int nUpper = 2 * mnRangeCount - 1;
     323       98813 :     while( nLower < nUpper )
     324             :     {
     325       79757 :         if( cChar >= mpRangeCodes[ nMid ] )
     326       54495 :             nLower = nMid;
     327             :         else
     328       25262 :             nUpper = nMid - 1;
     329       79757 :         nMid = (nLower + nUpper + 1) / 2;
     330             :     }
     331             : 
     332        9528 :     return nMid;
     333             : }
     334             : 
     335             : // -----------------------------------------------------------------------
     336             : 
     337        9528 : bool ImplFontCharMap::HasChar( sal_uInt32 cChar ) const
     338             : {
     339        9528 :     bool bHasChar = false;
     340             : 
     341        9528 :     if( mpStartGlyphs  == NULL ) { // only the char-ranges are known
     342           0 :         const int nRange = ImplFindRangeIndex( cChar );
     343           0 :         if( nRange==0 && cChar<mpRangeCodes[0] )
     344           0 :             return false;
     345           0 :         bHasChar = ((nRange & 1) == 0); // inside a range
     346             :     } else { // glyph mapping is available
     347        9528 :         const int nGlyphIndex = GetGlyphIndex( cChar );
     348        9528 :         bHasChar = (nGlyphIndex != 0); // not the notdef-glyph
     349             :     }
     350             : 
     351        9528 :     return bHasChar;
     352             : }
     353             : 
     354             : // -----------------------------------------------------------------------
     355             : 
     356        9528 : int ImplFontCharMap::GetGlyphIndex( sal_uInt32 cChar ) const
     357             : {
     358             :     // return -1 if the object doesn't know the glyph ids
     359        9528 :     if( !mpStartGlyphs )
     360           0 :         return -1;
     361             : 
     362             :     // return 0 if the unicode doesn't have a matching glyph
     363        9528 :     int nRange = ImplFindRangeIndex( cChar );
     364             :     // check that we are inside any range
     365        9528 :     if( (nRange == 0) && (cChar < mpRangeCodes[0]) ) {
     366             :         // symbol aliasing gives symbol fonts a second chance
     367           0 :         const bool bSymbolic = (mpRangeCodes[0]>=0xF000) & (mpRangeCodes[1]<=0xF0FF);
     368           0 :         if( !bSymbolic )
     369           0 :             return 0;
     370             :         // check for symbol aliasing (U+00xx <-> U+F0xx)
     371           0 :         cChar |= 0xF000;
     372           0 :         nRange = ImplFindRangeIndex( cChar );
     373             :     }
     374             :     // check that we are inside a range
     375        9528 :     if( (nRange & 1) != 0 )
     376        8660 :         return 0;
     377             : 
     378             :     // get glyph index directly or indirectly
     379         868 :     int nGlyphIndex = cChar - mpRangeCodes[ nRange ];
     380         868 :     const int nStartIndex = mpStartGlyphs[ nRange/2 ];
     381         868 :     if( nStartIndex >= 0 ) {
     382             :         // the glyph index can be calculated
     383         868 :         nGlyphIndex += nStartIndex;
     384             :     } else {
     385             :         // the glyphid array has the glyph index
     386           0 :         nGlyphIndex = mpGlyphIds[ nGlyphIndex - nStartIndex ];
     387             :     }
     388             : 
     389         868 :     return nGlyphIndex;
     390             : }
     391             : 
     392             : // -----------------------------------------------------------------------
     393             : 
     394             : // returns the number of chars supported by the font, which
     395             : // are inside the unicode range from cMin to cMax (inclusive)
     396           0 : int ImplFontCharMap::CountCharsInRange( sal_uInt32 cMin, sal_uInt32 cMax ) const
     397             : {
     398           0 :     int nCount = 0;
     399             : 
     400             :     // find and adjust range and char count for cMin
     401           0 :     int nRangeMin = ImplFindRangeIndex( cMin );
     402           0 :     if( nRangeMin & 1 )
     403           0 :         ++nRangeMin;
     404           0 :     else if( cMin > mpRangeCodes[ nRangeMin ] )
     405           0 :         nCount -= cMin - mpRangeCodes[ nRangeMin ];
     406             : 
     407             :     // find and adjust range and char count for cMax
     408           0 :     int nRangeMax = ImplFindRangeIndex( cMax );
     409           0 :     if( nRangeMax & 1 )
     410           0 :         --nRangeMax;
     411             :     else
     412           0 :         nCount -= mpRangeCodes[ nRangeMax+1 ] - cMax - 1;
     413             : 
     414             :     // count chars in complete ranges between cMin and cMax
     415           0 :     for( int i = nRangeMin; i <= nRangeMax; i+=2 )
     416           0 :         nCount += mpRangeCodes[i+1] - mpRangeCodes[i];
     417             : 
     418           0 :     return nCount;
     419             : }
     420             : 
     421             : // -----------------------------------------------------------------------
     422             : 
     423         331 : sal_uInt32 ImplFontCharMap::GetFirstChar() const
     424             : {
     425         331 :     return mpRangeCodes[0];
     426             : }
     427             : 
     428             : // -----------------------------------------------------------------------
     429             : 
     430           0 : sal_uInt32 ImplFontCharMap::GetLastChar() const
     431             : {
     432           0 :     return (mpRangeCodes[ 2*mnRangeCount-1 ] - 1);
     433             : }
     434             : 
     435             : // -----------------------------------------------------------------------
     436             : 
     437           0 : sal_uInt32 ImplFontCharMap::GetNextChar( sal_uInt32 cChar ) const
     438             : {
     439           0 :     if( cChar < GetFirstChar() )
     440           0 :         return GetFirstChar();
     441           0 :     if( cChar >= GetLastChar() )
     442           0 :         return GetLastChar();
     443             : 
     444           0 :     int nRange = ImplFindRangeIndex( cChar + 1 );
     445           0 :     if( nRange & 1 )                       // outside of range?
     446           0 :         return mpRangeCodes[ nRange + 1 ]; // => first in next range
     447           0 :     return (cChar + 1);
     448             : }
     449             : 
     450             : // -----------------------------------------------------------------------
     451             : 
     452           0 : sal_uInt32 ImplFontCharMap::GetPrevChar( sal_uInt32 cChar ) const
     453             : {
     454           0 :     if( cChar <= GetFirstChar() )
     455           0 :         return GetFirstChar();
     456           0 :     if( cChar > GetLastChar() )
     457           0 :         return GetLastChar();
     458             : 
     459           0 :     int nRange = ImplFindRangeIndex( cChar - 1 );
     460           0 :     if( nRange & 1 )                            // outside a range?
     461           0 :         return (mpRangeCodes[ nRange ] - 1);    // => last in prev range
     462           0 :     return (cChar - 1);
     463             : }
     464             : 
     465             : // -----------------------------------------------------------------------
     466             : 
     467           0 : int ImplFontCharMap::GetIndexFromChar( sal_uInt32 cChar ) const
     468             : {
     469             :     // TODO: improve linear walk?
     470           0 :     int nCharIndex = 0;
     471           0 :     const sal_uInt32* pRange = &mpRangeCodes[0];
     472           0 :     for( int i = 0; i < mnRangeCount; ++i )
     473             :     {
     474           0 :         sal_uInt32 cFirst = *(pRange++);
     475           0 :         sal_uInt32 cLast  = *(pRange++);
     476           0 :         if( cChar >= cLast )
     477           0 :             nCharIndex += cLast - cFirst;
     478           0 :         else if( cChar >= cFirst )
     479           0 :             return nCharIndex + (cChar - cFirst);
     480             :         else
     481           0 :             break;
     482             :     }
     483             : 
     484           0 :     return -1;
     485             : }
     486             : 
     487             : // -----------------------------------------------------------------------
     488             : 
     489           0 : sal_uInt32 ImplFontCharMap::GetCharFromIndex( int nCharIndex ) const
     490             : {
     491             :     // TODO: improve linear walk?
     492           0 :     const sal_uInt32* pRange = &mpRangeCodes[0];
     493           0 :     for( int i = 0; i < mnRangeCount; ++i )
     494             :     {
     495           0 :         sal_uInt32 cFirst = *(pRange++);
     496           0 :         sal_uInt32 cLast  = *(pRange++);
     497           0 :         nCharIndex -= cLast - cFirst;
     498           0 :         if( nCharIndex < 0 )
     499           0 :             return (cLast + nCharIndex);
     500             :     }
     501             : 
     502             :     // we can only get here with an out-of-bounds charindex
     503           0 :     return mpRangeCodes[0];
     504             : }
     505             : 
     506             : // =======================================================================
     507             : 
     508        8742 : static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);}
     509        5367 : static unsigned GetUShort( const unsigned char* p ){ return((p[0]<<8) | p[1]);}
     510         934 : static int GetSShort( const unsigned char* p ){ return((static_cast<signed char>(p[0])<<8)|p[1]);}
     511             : 
     512             : // TODO: move CMAP parsing directly into the ImplFontCharMap class
     513          21 : bool ParseCMAP( const unsigned char* pCmap, int nLength, CmapResult& rResult )
     514             : {
     515          21 :     rResult.mpRangeCodes = NULL;
     516          21 :     rResult.mpStartGlyphs= NULL;
     517          21 :     rResult.mpGlyphIds   = NULL;
     518          21 :     rResult.mnRangeCount = 0;
     519          21 :     rResult.mbRecoded    = false;
     520          21 :     rResult.mbSymbolic   = false;
     521             : 
     522             :     // parse the table header and check for validity
     523          21 :     if( !pCmap || (nLength < 24) )
     524           0 :         return false;
     525             : 
     526          21 :     if( GetUShort( pCmap ) != 0x0000 ) // simple check for CMAP corruption
     527           0 :         return false;
     528             : 
     529          21 :     int nSubTables = GetUShort( pCmap + 2 );
     530          21 :     if( (nSubTables <= 0) || (nLength < (24 + 8*nSubTables)) )
     531           0 :         return false;
     532             : 
     533             :     // find the most interesting subtable in the CMAP
     534          21 :     rtl_TextEncoding eRecodeFrom = RTL_TEXTENCODING_UNICODE;
     535          21 :     int nOffset = 0;
     536          21 :     int nFormat = -1;
     537          21 :     int nBestVal = 0;
     538         106 :     for( const unsigned char* p = pCmap + 4; --nSubTables >= 0; p += 8 )
     539             :     {
     540          85 :         int nPlatform = GetUShort( p );
     541          85 :         int nEncoding = GetUShort( p+2 );
     542          85 :         int nPlatformEncoding = (nPlatform << 8) + nEncoding;
     543             : 
     544             :         int nValue;
     545          85 :         rtl_TextEncoding eTmpEncoding = RTL_TEXTENCODING_UNICODE;
     546          85 :         switch( nPlatformEncoding )
     547             :         {
     548           0 :             case 0x000: nValue = 20; break;                             // Unicode 1.0
     549           0 :             case 0x001: nValue = 21; break;                             // Unicode 1.1
     550           0 :             case 0x002: nValue = 22; break;                             // iso10646_1993
     551          21 :             case 0x003: nValue = 23; break;                             // UCS-2
     552          11 :             case 0x004: nValue = 24; break;                             // UCS-4
     553          21 :             case 0x100: nValue = 22; break;                             // Mac Unicode<2.0
     554           0 :             case 0x103: nValue = 23; break;                             // Mac Unicode>2.0
     555           0 :             case 0x300: nValue =  5; rResult.mbSymbolic = true; break;  // Win Symbol
     556          21 :             case 0x301: nValue = 28; break;                             // Win UCS-2
     557          11 :             case 0x30A: nValue = 29; break;                             // Win-UCS-4
     558           0 :             case 0x302: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_SHIFT_JIS; break;
     559           0 :             case 0x303: nValue = 12; eTmpEncoding = RTL_TEXTENCODING_GB_18030; break;
     560           0 :             case 0x304: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_BIG5; break;
     561           0 :             case 0x305: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_MS_949; break;
     562           0 :             case 0x306: nValue = 11; eTmpEncoding = RTL_TEXTENCODING_MS_1361; break;
     563           0 :             default:    nValue = 0; break;
     564             :         }
     565             : 
     566          85 :         if( nValue <= 0 )   // ignore unknown encodings
     567           0 :             continue;
     568             : 
     569          85 :         int nTmpOffset = GetUInt( p+4 );
     570          85 :         int nTmpFormat = GetUShort( pCmap + nTmpOffset );
     571          85 :         if( nTmpFormat == 12 )                  // 32bit code -> glyph map format
     572          22 :             nValue += 3;
     573          63 :         else if( nTmpFormat != 4 )              // 16bit code -> glyph map format
     574          21 :             continue;                           // ignore other formats
     575             : 
     576          64 :         if( nBestVal < nValue )
     577             :         {
     578          64 :             nBestVal = nValue;
     579          64 :             nOffset = nTmpOffset;
     580          64 :             nFormat = nTmpFormat;
     581          64 :             eRecodeFrom = eTmpEncoding;
     582             :         }
     583             :     }
     584             : 
     585             :     // parse the best CMAP subtable
     586          21 :     int nRangeCount = 0;
     587          21 :     sal_uInt32* pCodePairs = NULL;
     588          21 :     int* pStartGlyphs = NULL;
     589             : 
     590             :     typedef std::vector<sal_uInt16> U16Vector;
     591          21 :     U16Vector aGlyphIdArray;
     592          21 :     aGlyphIdArray.reserve( 0x1000 );
     593          21 :     aGlyphIdArray.push_back( 0 );
     594             : 
     595             :     // format 4, the most common 16bit char mapping table
     596          21 :     if( (nFormat == 4) && ((nOffset+16) < nLength) )
     597             :     {
     598          10 :         int nSegCountX2 = GetUShort( pCmap + nOffset + 6 );
     599          10 :         nRangeCount = nSegCountX2/2 - 1;
     600          10 :         pCodePairs = new sal_uInt32[ nRangeCount * 2 ];
     601          10 :         pStartGlyphs = new int[ nRangeCount ];
     602          10 :         const unsigned char* pLimitBase = pCmap + nOffset + 14;
     603          10 :         const unsigned char* pBeginBase = pLimitBase + nSegCountX2 + 2;
     604          10 :         const unsigned char* pDeltaBase = pBeginBase + nSegCountX2;
     605          10 :         const unsigned char* pOffsetBase = pDeltaBase + nSegCountX2;
     606          10 :         sal_uInt32* pCP = pCodePairs;
     607         944 :         for( int i = 0; i < nRangeCount; ++i )
     608             :         {
     609         934 :             const sal_uInt32 cMinChar = GetUShort( pBeginBase + 2*i );
     610         934 :             const sal_uInt32 cMaxChar = GetUShort( pLimitBase + 2*i );
     611         934 :             const int nGlyphDelta  = GetSShort( pDeltaBase + 2*i );
     612         934 :             const int nRangeOffset = GetUShort( pOffsetBase + 2*i );
     613         934 :             if( cMinChar > cMaxChar )   // no sane font should trigger this
     614           0 :                 break;
     615         934 :             if( cMaxChar == 0xFFFF )
     616           0 :                 break;
     617         934 :             *(pCP++) = cMinChar;
     618         934 :             *(pCP++) = cMaxChar + 1;
     619         934 :             if( !nRangeOffset ) {
     620             :                 // glyphid can be calculated directly
     621         915 :                 pStartGlyphs[i] = (cMinChar + nGlyphDelta) & 0xFFFF;
     622             :             } else {
     623             :                 // update the glyphid-array with the glyphs in this range
     624          19 :                 pStartGlyphs[i] = -(int)aGlyphIdArray.size();
     625          19 :                 const unsigned char* pGlyphIdPtr = pOffsetBase + 2*i + nRangeOffset;
     626        2277 :                 for( sal_uInt32 c = cMinChar; c <= cMaxChar; ++c, pGlyphIdPtr+=2 ) {
     627        2258 :                     const int nGlyphIndex = GetUShort( pGlyphIdPtr ) + nGlyphDelta;
     628        2258 :                     aGlyphIdArray.push_back( static_cast<sal_uInt16>(nGlyphIndex) );
     629             :                 }
     630             :             }
     631             :         }
     632          10 :         nRangeCount = (pCP - pCodePairs) / 2;
     633             :     }
     634             :     // format 12, the most common 32bit char mapping table
     635          11 :     else if( (nFormat == 12) && ((nOffset+16) < nLength) )
     636             :     {
     637          11 :         nRangeCount = GetUInt( pCmap + nOffset + 12 );
     638          11 :         pCodePairs = new sal_uInt32[ nRangeCount * 2 ];
     639          11 :         pStartGlyphs = new int[ nRangeCount ];
     640          11 :         const unsigned char* pGroup = pCmap + nOffset + 16;
     641          11 :         sal_uInt32* pCP = pCodePairs;
     642        2893 :         for( int i = 0; i < nRangeCount; ++i )
     643             :         {
     644        2882 :             sal_uInt32 cMinChar = GetUInt( pGroup + 0 );
     645        2882 :             sal_uInt32 cMaxChar = GetUInt( pGroup + 4 );
     646        2882 :             int nGlyphId = GetUInt( pGroup + 8 );
     647        2882 :             pGroup += 12;
     648        2882 :             if( cMinChar > cMaxChar )   // no sane font should trigger this
     649           0 :                 break;
     650        2882 :             *(pCP++) = cMinChar;
     651        2882 :             *(pCP++) = cMaxChar + 1;
     652        2882 :             pStartGlyphs[i] = nGlyphId;
     653             :         }
     654          11 :         nRangeCount = (pCP - pCodePairs) / 2;
     655             :     }
     656             : 
     657             :     // check if any subtable resulted in something usable
     658          21 :     if( nRangeCount <= 0 )
     659             :     {
     660           0 :         delete[] pCodePairs;
     661           0 :         delete[] pStartGlyphs;
     662             : 
     663             :         // even when no CMAP is available we know it for symbol fonts
     664           0 :         if( rResult.mbSymbolic )
     665             :         {
     666           0 :             pCodePairs = new sal_uInt32[4];
     667           0 :             pCodePairs[0] = 0x0020;    // aliased symbols
     668           0 :             pCodePairs[1] = 0x0100;
     669           0 :             pCodePairs[2] = 0xF020;    // original symbols
     670           0 :             pCodePairs[3] = 0xF100;
     671           0 :             rResult.mpRangeCodes = pCodePairs;
     672           0 :             rResult.mnRangeCount = 2;
     673           0 :             return true;
     674             :         }
     675             : 
     676           0 :         return false;
     677             :     }
     678             : 
     679             :     // recode the code ranges to their unicode encoded ranges if needed
     680          21 :     rtl_TextToUnicodeConverter aConverter = NULL;
     681          21 :     rtl_UnicodeToTextContext aCvtContext = NULL;
     682             : 
     683          21 :     rResult.mbRecoded = ( eRecodeFrom != RTL_TEXTENCODING_UNICODE );
     684          21 :     if( rResult.mbRecoded )
     685             :     {
     686           0 :         aConverter = rtl_createTextToUnicodeConverter( eRecodeFrom );
     687           0 :         aCvtContext = rtl_createTextToUnicodeContext( aConverter );
     688             :     }
     689             : 
     690          21 :     if( aConverter && aCvtContext )
     691             :     {
     692             :         // determine the set of supported unicodes from encoded ranges
     693             :         typedef std::set<sal_uInt32> IntSet;
     694           0 :         IntSet aSupportedUnicodes;
     695             : 
     696             :         static const int NINSIZE = 64;
     697             :         static const int NOUTSIZE = 64;
     698             :         sal_Char    cCharsInp[ NINSIZE ];
     699             :         sal_Unicode cCharsOut[ NOUTSIZE ];
     700           0 :         sal_uInt32* pCP = pCodePairs;
     701           0 :         for( int i = 0; i < nRangeCount; ++i )
     702             :         {
     703           0 :             sal_uInt32 cMin = *(pCP++);
     704           0 :             sal_uInt32 cEnd = *(pCP++);
     705           0 :             while( cMin < cEnd )
     706             :             {
     707           0 :                 int j = 0;
     708           0 :                 for (; (cMin < cEnd) && (j < (NINSIZE-1)); ++cMin)
     709             :                 {
     710           0 :                     if( cMin >= 0x0100 )
     711           0 :                         cCharsInp[ j++ ] = static_cast<sal_Char>(cMin >> 8);
     712           0 :                     if( (cMin >= 0x0100) || (cMin < 0x00A0)  )
     713           0 :                         cCharsInp[ j++ ] = static_cast<sal_Char>(cMin);
     714             :                 }
     715             : 
     716             :                 sal_uInt32 nCvtInfo;
     717             :                 sal_Size nSrcCvtBytes;
     718             :                 int nOutLen = rtl_convertTextToUnicode(
     719             :                     aConverter, aCvtContext,
     720             :                     cCharsInp, j, cCharsOut, NOUTSIZE,
     721             :                     RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE
     722             :                     | RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE,
     723           0 :                     &nCvtInfo, &nSrcCvtBytes );
     724             : 
     725           0 :                 for( j = 0; j < nOutLen; ++j )
     726           0 :                     aSupportedUnicodes.insert( cCharsOut[j] );
     727             :             }
     728             :         }
     729             : 
     730           0 :         rtl_destroyTextToUnicodeConverter( aCvtContext );
     731           0 :         rtl_destroyTextToUnicodeConverter( aConverter );
     732             : 
     733             :         // convert the set of supported unicodes to ranges
     734             :         typedef std::vector<sal_uInt32> IntVector;
     735           0 :         IntVector aSupportedRanges;
     736             : 
     737           0 :         IntSet::const_iterator itChar = aSupportedUnicodes.begin();
     738           0 :         for(; itChar != aSupportedUnicodes.end(); ++itChar )
     739             :         {
     740           0 :             if( aSupportedRanges.empty()
     741           0 :             || (aSupportedRanges.back() != *itChar) )
     742             :             {
     743             :                 // add new range beginning with current unicode
     744           0 :                 aSupportedRanges.push_back( *itChar );
     745           0 :                 aSupportedRanges.push_back( 0 );
     746             :             }
     747             : 
     748             :             // extend existing range to include current unicode
     749           0 :             aSupportedRanges.back() = *itChar + 1;
     750             :         }
     751             : 
     752             :         // glyph mapping for non-unicode fonts not implemented
     753           0 :         delete[] pStartGlyphs;
     754           0 :         pStartGlyphs = NULL;
     755           0 :         aGlyphIdArray.clear();
     756             : 
     757             :         // make a pCodePairs array using the vector from above
     758           0 :         delete[] pCodePairs;
     759           0 :         nRangeCount = aSupportedRanges.size() / 2;
     760           0 :         if( nRangeCount <= 0 )
     761           0 :             return false;
     762           0 :         pCodePairs = new sal_uInt32[ nRangeCount * 2 ];
     763           0 :         IntVector::const_iterator itInt = aSupportedRanges.begin();
     764           0 :         for( pCP = pCodePairs; itInt != aSupportedRanges.end(); ++itInt )
     765           0 :             *(pCP++) = *itInt;
     766             :     }
     767             : 
     768             :     // prepare the glyphid-array if needed
     769             :     // TODO: merge ranges if they are close enough?
     770          21 :     sal_uInt16* pGlyphIds = NULL;
     771          21 :     if( !aGlyphIdArray.empty())
     772             :     {
     773          21 :         pGlyphIds = new sal_uInt16[ aGlyphIdArray.size() ];
     774          21 :         sal_uInt16* pOut = pGlyphIds;
     775          21 :         U16Vector::const_iterator it = aGlyphIdArray.begin();
     776        2321 :         while( it != aGlyphIdArray.end() )
     777        2279 :             *(pOut++) = *(it++);
     778             :     }
     779             : 
     780             :     // update the result struct
     781          21 :     rResult.mpRangeCodes = pCodePairs;
     782          21 :     rResult.mpStartGlyphs = pStartGlyphs;
     783          21 :     rResult.mnRangeCount = nRangeCount;
     784          21 :     rResult.mpGlyphIds = pGlyphIds;
     785          21 :     return true;
     786             : }
     787             : 
     788             : // =======================================================================
     789             : 
     790        2841 : FontCharMap::FontCharMap()
     791        2841 : :   mpImpl( ImplFontCharMap::GetDefaultMap() )
     792             : {
     793        2841 :     mpImpl->AddReference();
     794        2841 : }
     795             : 
     796             : // -----------------------------------------------------------------------
     797             : 
     798        2841 : FontCharMap::~FontCharMap()
     799             : {
     800        2841 :     mpImpl->DeReference();
     801        2841 :     mpImpl = NULL;
     802        2841 : }
     803             : 
     804             : // -----------------------------------------------------------------------
     805             : 
     806           0 : int FontCharMap::GetCharCount() const
     807             : {
     808           0 :     return mpImpl->GetCharCount();
     809             : }
     810             : 
     811             : // -----------------------------------------------------------------------
     812             : 
     813           0 : int FontCharMap::CountCharsInRange( sal_uInt32 cMin, sal_uInt32 cMax ) const
     814             : {
     815           0 :     return mpImpl->CountCharsInRange( cMin, cMax );
     816             : }
     817             : 
     818             : // -----------------------------------------------------------------------
     819             : 
     820        5682 : void FontCharMap::Reset( const ImplFontCharMap* pNewMap )
     821             : {
     822        5682 :     mpImpl->DeReference();
     823        5682 :     if( pNewMap == NULL )
     824        2841 :         mpImpl = ImplFontCharMap::GetDefaultMap();
     825        2841 :     else if( pNewMap != mpImpl )
     826        2841 :         mpImpl = pNewMap;
     827        5682 :     mpImpl->AddReference();
     828        5682 : }
     829             : 
     830             : // -----------------------------------------------------------------------
     831             : 
     832        2841 : sal_Bool FontCharMap::IsDefaultMap() const
     833             : {
     834        2841 :     return mpImpl->IsDefaultMap();
     835             : }
     836             : 
     837             : // -----------------------------------------------------------------------
     838             : 
     839        9528 : sal_Bool FontCharMap::HasChar( sal_uInt32 cChar ) const
     840             : {
     841        9528 :     return mpImpl->HasChar( cChar );
     842             : }
     843             : 
     844             : // -----------------------------------------------------------------------
     845             : 
     846         331 : sal_uInt32 FontCharMap::GetFirstChar() const
     847             : {
     848         331 :     return mpImpl->GetFirstChar();
     849             : }
     850             : 
     851             : // -----------------------------------------------------------------------
     852             : 
     853           0 : sal_uInt32 FontCharMap::GetNextChar( sal_uInt32 cChar ) const
     854             : {
     855           0 :     return mpImpl->GetNextChar( cChar );
     856             : }
     857             : 
     858             : // -----------------------------------------------------------------------
     859             : 
     860           0 : sal_uInt32 FontCharMap::GetPrevChar( sal_uInt32 cChar ) const
     861             : {
     862           0 :     return mpImpl->GetPrevChar( cChar );
     863             : }
     864             : 
     865             : // -----------------------------------------------------------------------
     866             : 
     867           0 : int FontCharMap::GetIndexFromChar( sal_uInt32 cChar ) const
     868             : {
     869           0 :     return mpImpl->GetIndexFromChar( cChar );
     870             : }
     871             : 
     872             : // -----------------------------------------------------------------------
     873             : 
     874           0 : sal_uInt32 FontCharMap::GetCharFromIndex( int nIndex ) const
     875             : {
     876           0 :     return mpImpl->GetCharFromIndex( nIndex );
     877             : }
     878             : 
     879             : // =======================================================================
     880             : 
     881             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10