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