filter/source/svg/svgfontexport.cxx

   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 "svgfontexport.hxx"
  22 #include "svgfilter.hxx"
  23 #include "svgwriter.hxx"
  24
  25 #include <vcl/unohelp.hxx>
  26 #include <vcl/font.hxx>
  27 #include <vcl/outdev.hxx>
  28 #include <vcl/settings.hxx>
  29
  30 static const sal_Int32 nFontEM = 2048;
  31
  32
  33 SVGFontExport::SVGFontExport( SVGExport& rExport, const ::std::vector< ObjectRepresentation >& rObjects ) :
  34     mrExport( rExport ),
  35     maObjects( rObjects ),
  36     mnCurFontId( 0 )
  37 {
  38 }
  39
  40
  41 SVGFontExport::~SVGFontExport()
  42 {
  43 }
  44
  45
  46 SVGFontExport::GlyphSet& SVGFontExport::implGetGlyphSet( const vcl::Font& rFont )
  47 {
  48     FontWeight      eWeight( WEIGHT_NORMAL );
  49     FontItalic      eItalic( ITALIC_NONE );
  50     const OUString& aFontName( rFont.GetFamilyName() );
  51     sal_Int32       nNextTokenPos( 0 );
  52
  53     switch( rFont.GetWeight() )
  54     {
  55         case WEIGHT_BOLD:
  56         case WEIGHT_ULTRABOLD:
  57         case WEIGHT_BLACK:
  58             eWeight = WEIGHT_BOLD;
  59         break;
  60
  61         default:
  62         break;
  63     }
  64
  65     if( rFont.GetItalic() != ITALIC_NONE )
  66         eItalic = ITALIC_NORMAL;
  67
  68     return( maGlyphTree[ aFontName.getToken( 0, ';', nNextTokenPos ) ][ eWeight ][ eItalic ] );
  69 }
  70
  71
  72 void SVGFontExport::implCollectGlyphs()
  73 {
  74     ScopedVclPtrInstance< VirtualDevice > pVDev;
  75     ObjectVector::const_iterator aIter( maObjects.begin() );
  76
  77     pVDev->EnableOutput( false );
  78
  79     while( aIter != maObjects.end() )
  80     {
  81         if( (*aIter).HasRepresentation() )
  82         {
  83             const GDIMetaFile& rMtf = (*aIter).GetRepresentation();
  84
  85             pVDev->Push();
  86
  87             for( size_t i = 0, nCount = rMtf.GetActionSize(); i < nCount; ++i )
  88             {
  89                 OUString             aText;
  90                 MetaAction*          pAction = rMtf.GetAction( i );
  91                 const MetaActionType nType = pAction->GetType();
  92
  93                 switch( nType )
  94                 {
  95                     case( MetaActionType::TEXT ):
  96                     {
  97                         const MetaTextAction* pA = static_cast<const MetaTextAction*>(pAction);
  98                         sal_Int32             aLength=std::min( pA->GetText().getLength(), pA->GetLen() );
  99                         aText = pA->GetText().copy( pA->GetIndex(), aLength );
 100                     }
 101                     break;
 102
 103                     case( MetaActionType::TEXTRECT ):
 104                     {
 105                         const MetaTextRectAction* pA = static_cast<const MetaTextRectAction*>(pAction);
 106                         aText = pA->GetText();
 107                     }
 108                     break;
 109
 110                     case( MetaActionType::TEXTARRAY ):
 111                     {
 112                         const MetaTextArrayAction*  pA = static_cast<const MetaTextArrayAction*>(pAction);
 113                         sal_Int32                   aLength=std::min( pA->GetText().getLength(), pA->GetLen() );
 114                         aText = pA->GetText().copy( pA->GetIndex(), aLength );
 115                     }
 116                     break;
 117
 118                     case( MetaActionType::STRETCHTEXT ):
 119                     {
 120                         const MetaStretchTextAction* pA = static_cast<const MetaStretchTextAction*>(pAction);
 121                         sal_Int32                    aLength=std::min( pA->GetText().getLength(), pA->GetLen() );
 122                         aText = pA->GetText().copy( pA->GetIndex(), aLength );
 123                     }
 124                     break;
 125
 126                     default:
 127                         pAction->Execute( pVDev );
 128                     break;
 129                 }
 130
 131                 if( !aText.isEmpty() )
 132                 {
 133                     GlyphSet& rGlyphSet = implGetGlyphSet( pVDev->GetFont() );
 134                     css::uno::Reference< css::i18n::XBreakIterator > xBI(
 135                         vcl::unohelper::CreateBreakIterator() );
 136
 137                     if( xBI.is() )
 138                     {
 139                         const css::lang::Locale&   rLocale = Application::GetSettings().GetLanguageTag().getLocale();
 140                         sal_Int32                               nCurPos = 0, nLastPos = -1;
 141
 142                         while( ( nCurPos < aText.getLength() ) && ( nCurPos > nLastPos ) )
 143                         {
 144                             sal_Int32 nCount2 = 1;
 145
 146                             nLastPos = nCurPos;
 147                             nCurPos = xBI->nextCharacters( aText, nCurPos, rLocale,
 148                                                            css::i18n::CharacterIteratorMode::SKIPCELL,
 149                                                            nCount2, nCount2 );
 150
 151                             rGlyphSet.insert( aText.copy( nLastPos, nCurPos - nLastPos ) );
 152                         }
 153                     }
 154                     else
 155                     {
 156                         const sal_Unicode* pStr = aText.getStr();
 157
 158                         for( sal_uInt32 k = 0, nLen = aText.getLength(); k < nLen; ++k )
 159                             rGlyphSet.insert( OUString( pStr[ k ] ) );
 160                     }
 161                 }
 162             }
 163
 164             pVDev->Pop();
 165         }
 166
 167         ++aIter;
 168     }
 169 }
 170
 171
 172 void SVGFontExport::implEmbedFont( const vcl::Font& rFont )
 173 {
 174     if( mrExport.IsEmbedFonts() )
 175     {
 176         GlyphSet& rGlyphSet = implGetGlyphSet( rFont );
 177
 178         if( !rGlyphSet.empty() )
 179         {
 180             GlyphSet::const_iterator    aIter( rGlyphSet.begin() );
 181             const OUString              aEmbeddedFontStr( "EmbeddedFont_" );
 182
 183             {
 184                 SvXMLElementExport  aExp( mrExport, XML_NAMESPACE_NONE, "defs", true, true );
 185                 OUString     aCurIdStr( aEmbeddedFontStr );
 186                 OUString     aUnitsPerEM( OUString::number( nFontEM ) );
 187                 ScopedVclPtrInstance< VirtualDevice > pVDev;
 188                 vcl::Font           aFont( rFont );
 189
 190                 aFont.SetFontSize( Size( 0, nFontEM ) );
 191                 aFont.SetAlignment( ALIGN_BASELINE );
 192
 193                 pVDev->SetMapMode( MapUnit::Map100thMM );
 194                 pVDev->SetFont( aFont );
 195
 196                 mrExport.AddAttribute( XML_NAMESPACE_NONE, "id", aCurIdStr += OUString::number( ++mnCurFontId ) );
 197                 mrExport.AddAttribute( XML_NAMESPACE_NONE, "horiz-adv-x", aUnitsPerEM );
 198
 199                 {
 200                     SvXMLElementExport  aExp2( mrExport, XML_NAMESPACE_NONE, "font", true, true );
 201                     OUString     aFontWeight;
 202                     OUString     aFontStyle;
 203                     const Size         aSize( nFontEM, nFontEM );
 204
 205                     // Font Weight
 206                     if( aFont.GetWeight() != WEIGHT_NORMAL )
 207                         aFontWeight = "bold";
 208                     else
 209                         aFontWeight = "normal";
 210
 211                     // Font Italic
 212                     if( aFont.GetItalic() != ITALIC_NONE )
 213                         aFontStyle = "italic";
 214                     else
 215                         aFontStyle = "normal";
 216
 217                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "font-family", GetMappedFontName( rFont.GetFamilyName() ) );
 218                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "units-per-em", aUnitsPerEM );
 219                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "font-weight", aFontWeight );
 220                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "font-style", aFontStyle );
 221                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "ascent", OUString::number( pVDev->GetFontMetric().GetAscent() ) );
 222                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "descent", OUString::number( pVDev->GetFontMetric().GetDescent() ) );
 223
 224                     {
 225                         SvXMLElementExport aExp3( mrExport, XML_NAMESPACE_NONE, "font-face", true, true );
 226                     }
 227
 228                     mrExport.AddAttribute( XML_NAMESPACE_NONE, "horiz-adv-x", OUString::number( aSize.Width() ) );
 229
 230                     {
 231                         const Point         aPos;
 232                         const tools::PolyPolygon   aMissingGlyphPolyPoly( Rectangle( aPos, aSize ) );
 233
 234                         mrExport.AddAttribute( XML_NAMESPACE_NONE, "d", SVGActionWriter::GetPathString( aMissingGlyphPolyPoly, false ) );
 235
 236                         {
 237                             SvXMLElementExport  aExp4( mrExport, XML_NAMESPACE_NONE, "missing-glyph", true, true );
 238                         }
 239                     }
 240
 241                     while( aIter != rGlyphSet.end() )
 242                     {
 243                         implEmbedGlyph( *pVDev.get(), *aIter );
 244                         ++aIter;
 245                     }
 246                 }
 247             }
 248         }
 249     }
 250 }
 251
 252
 253 void SVGFontExport::implEmbedGlyph( OutputDevice& rOut, const OUString& rCellStr )
 254 {
 255     tools::PolyPolygon         aPolyPoly;
 256     const sal_Unicode   nSpace = ' ';
 257
 258     if( rOut.GetTextOutline( aPolyPoly, rCellStr ) )
 259     {
 260         Rectangle aBoundRect;
 261
 262         aPolyPoly.Scale( 1.0, -1.0 );
 263
 264         if( !rOut.GetTextBoundRect( aBoundRect, rCellStr ) )
 265             aBoundRect = Rectangle( Point( 0, 0 ), Size( rOut.GetTextWidth( rCellStr ), 0 ) );
 266
 267         mrExport.AddAttribute( XML_NAMESPACE_NONE, "unicode", rCellStr );
 268
 269         if( rCellStr[ 0 ] == nSpace && rCellStr.getLength() == 1 )
 270             aBoundRect = Rectangle( Point( 0, 0 ), Size( rOut.GetTextWidth( OUString(' ') ), 0 ) );
 271
 272         mrExport.AddAttribute( XML_NAMESPACE_NONE, "horiz-adv-x", OUString::number( aBoundRect.GetWidth() ) );
 273
 274         const OUString aPathString( SVGActionWriter::GetPathString( aPolyPoly, false ) );
 275         if( !aPathString.isEmpty() )
 276         {
 277             mrExport.AddAttribute( XML_NAMESPACE_NONE, "d", aPathString );
 278         }
 279
 280         {
 281             SvXMLElementExport aExp( mrExport, XML_NAMESPACE_NONE, "glyph", true, true );
 282         }
 283     }
 284 }
 285
 286
 287 void SVGFontExport::EmbedFonts()
 288 {
 289     implCollectGlyphs();
 290
 291     GlyphTree::const_iterator aGlyphTreeIter( maGlyphTree.begin() );
 292
 293     while( aGlyphTreeIter != maGlyphTree.end() )
 294     {
 295         const FontWeightMap&            rFontWeightMap = (*aGlyphTreeIter).second;
 296         FontWeightMap::const_iterator   aFontWeightIter( rFontWeightMap.begin() );
 297
 298         while( aFontWeightIter != rFontWeightMap.end() )
 299         {
 300             const FontItalicMap&            rFontItalicMap = (*aFontWeightIter).second;
 301             FontItalicMap::const_iterator   aFontItalicIter( rFontItalicMap.begin() );
 302
 303             while( aFontItalicIter != rFontItalicMap.end() )
 304             {
 305                 vcl::Font aFont;
 306
 307                 aFont.SetFamilyName( (*aGlyphTreeIter).first );
 308                 aFont.SetWeight( (*aFontWeightIter).first );
 309                 aFont.SetItalic( (*aFontItalicIter).first );
 310
 311                 implEmbedFont( aFont );
 312
 313                 ++aFontItalicIter;
 314             }
 315
 316             ++aFontWeightIter;
 317         }
 318
 319         ++aGlyphTreeIter;
 320     }
 321 }
 322
 323
 324 OUString SVGFontExport::GetMappedFontName( const OUString& rFontName ) const
 325 {
 326     sal_Int32       nNextTokenPos( 0 );
 327     OUString aRet( rFontName.getToken( 0, ';', nNextTokenPos ) );
 328
 329     if( mnCurFontId )
 330         aRet += " embedded";
 331
 332     return aRet;
 333 }
 334
 335 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */