xmloff/source/style/XMLFontStylesContext.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 #include <xmloff/XMLFontStylesContext.hxx>
  21 #include "XMLFontStylesContext_impl.hxx"
  22
  23 #include <com/sun/star/awt/FontFamily.hpp>
  24 #include <com/sun/star/awt/FontPitch.hpp>
  25 #include <com/sun/star/embed/ElementModes.hpp>
  26 #include <com/sun/star/embed/XStorage.hpp>
  27
  28 #include <comphelper/seqstream.hxx>
  29
  30 #include <sal/log.hxx>
  31
  32 #include <xmloff/xmlnamespace.hxx>
  33 #include <xmloff/xmltoken.hxx>
  34 #include "fonthdl.hxx"
  35 #include <xmloff/xmlimp.hxx>
  36 #include <xmloff/maptype.hxx>
  37 #include <xmloff/XMLBase64ImportContext.hxx>
  38
  39
  40 using namespace ::com::sun::star;
  41 using namespace ::com::sun::star::uno;
  42 using namespace ::com::sun::star::xml::sax;
  43 using namespace ::com::sun::star::container;
  44 using namespace ::com::sun::star::awt;
  45 using namespace ::xmloff::token;
  46
  47
  48 #define XML_STYLE_FAMILY_FONT XmlStyleFamily::PAGE_MASTER
  49
  50 XMLFontStyleContextFontFace::XMLFontStyleContextFontFace( SvXMLImport& rImport,
  51         XMLFontStylesContext& rStyles ) :
  52     SvXMLStyleContext( rImport, XML_STYLE_FAMILY_FONT ),
  53     xStyles( &rStyles )
  54 {
  55     aFamilyName <<= OUString();
  56     aStyleName <<= OUString();
  57     aFamily <<= sal_Int16(awt::FontFamily::DONTKNOW);
  58     aPitch <<= sal_Int16(awt::FontPitch::DONTKNOW);
  59     aEnc <<= static_cast<sal_Int16>(rStyles.GetDfltCharset());
  60 }
  61
  62 void XMLFontStyleContextFontFace::SetAttribute( sal_Int32 nElement,
  63                                         const OUString& rValue )
  64 {
  65     SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter();
  66     Any aAny;
  67
  68     switch(nElement)
  69     {
  70     case XML_ELEMENT(SVG, XML_FONT_FAMILY):
  71     case XML_ELEMENT(SVG_COMPAT, XML_FONT_FAMILY):
  72         if( GetStyles()->GetFamilyNameHdl().importXML( rValue, aAny,
  73                                                           rUnitConv ) )
  74             aFamilyName = aAny;
  75         break;
  76     case XML_ELEMENT(STYLE, XML_FONT_ADORNMENTS):
  77         aStyleName <<= rValue;
  78         break;
  79     case XML_ELEMENT(STYLE, XML_FONT_FAMILY_GENERIC):
  80         if( GetStyles()->GetFamilyHdl().importXML( rValue, aAny,
  81                                                       rUnitConv ) )
  82             aFamily = aAny;
  83         break;
  84     case XML_ELEMENT(STYLE, XML_FONT_PITCH):
  85         if( GetStyles()->GetPitchHdl().importXML( rValue, aAny,
  86                                                       rUnitConv ) )
  87             aPitch = aAny;
  88         break;
  89     case XML_ELEMENT(STYLE, XML_FONT_CHARSET):
  90         if( GetStyles()->GetEncodingHdl().importXML( rValue, aAny,
  91                                                       rUnitConv ) )
  92             aEnc = std::move(aAny);
  93         break;
  94     default:
  95         SvXMLStyleContext::SetAttribute( nElement, rValue );
  96         break;
  97     }
  98 }
  99
 100 XMLFontStyleContextFontFace::~XMLFontStyleContextFontFace()
 101 {
 102 }
 103
 104 void XMLFontStyleContextFontFace::FillProperties(
 105         ::std::vector< XMLPropertyState > &rProps,
 106         sal_Int32 nFamilyNameIdx,
 107         sal_Int32 nStyleNameIdx,
 108         sal_Int32 nFamilyIdx,
 109         sal_Int32 nPitchIdx,
 110         sal_Int32 nCharsetIdx ) const
 111 {
 112     if( nFamilyNameIdx != -1 )
 113     {
 114         XMLPropertyState aPropState( nFamilyNameIdx, aFamilyName );
 115         rProps.push_back( aPropState );
 116     }
 117     if( nStyleNameIdx != -1 )
 118     {
 119         XMLPropertyState aPropState( nStyleNameIdx, aStyleName );
 120         rProps.push_back( aPropState );
 121     }
 122     if( nFamilyIdx != -1 )
 123     {
 124         XMLPropertyState aPropState( nFamilyIdx, aFamily );
 125         rProps.push_back( aPropState );
 126     }
 127     if( nPitchIdx != -1 )
 128     {
 129         XMLPropertyState aPropState( nPitchIdx, aPitch );
 130         rProps.push_back( aPropState );
 131     }
 132     if( nCharsetIdx != -1 )
 133     {
 134         XMLPropertyState aPropState( nCharsetIdx, aEnc );
 135         rProps.push_back( aPropState );
 136     }
 137 }
 138
 139 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFace::createFastChildContext(
 140         sal_Int32 nElement,
 141         const css::uno::Reference< css::xml::sax::XFastAttributeList > &  )
 142 {
 143     if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_SRC) ||
 144         nElement == XML_ELEMENT(SVG_COMPAT, XML_FONT_FACE_SRC) )
 145         return new XMLFontStyleContextFontFaceSrc( GetImport(), *this );
 146     else
 147         XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
 148     return nullptr;
 149 }
 150
 151 OUString XMLFontStyleContextFontFace::familyName() const
 152 {
 153     OUString ret;
 154     aFamilyName >>= ret;
 155     return ret;
 156 }
 157
 158
 159 XMLFontStyleContextFontFaceFormat::XMLFontStyleContextFontFaceFormat( SvXMLImport& rImport,
 160         XMLFontStyleContextFontFaceUri& _uri )
 161     : SvXMLStyleContext( rImport )
 162     , uri(_uri)
 163 {
 164 }
 165
 166 void XMLFontStyleContextFontFaceFormat::SetAttribute( sal_Int32 nElement,
 167     const OUString& rValue )
 168 {
 169     if( nElement == XML_ELEMENT(SVG, XML_STRING) || nElement == XML_ELEMENT(SVG_COMPAT, XML_STRING))
 170         uri.SetFormat(rValue);
 171     else
 172         SvXMLStyleContext::SetAttribute( nElement, rValue );
 173 }
 174
 175
 176 XMLFontStyleContextFontFaceSrc::XMLFontStyleContextFontFaceSrc( SvXMLImport& rImport,
 177         const XMLFontStyleContextFontFace& _font )
 178     : SvXMLImportContext( rImport )
 179     , font( _font )
 180 {
 181 }
 182
 183 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFaceSrc::createFastChildContext(
 184         sal_Int32 nElement,
 185         const css::uno::Reference< css::xml::sax::XFastAttributeList > & /*xAttrList*/ )
 186 {
 187     if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_URI) ||
 188         nElement == XML_ELEMENT(SVG_COMPAT, XML_FONT_FACE_URI) )
 189         return new XMLFontStyleContextFontFaceUri( GetImport(), font );
 190     XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
 191     return nullptr;
 192 }
 193
 194
 195 XMLFontStyleContextFontFaceUri::XMLFontStyleContextFontFaceUri( SvXMLImport& rImport,
 196         const XMLFontStyleContextFontFace& _font )
 197     : SvXMLStyleContext( rImport )
 198     , font( _font )
 199 {
 200 }
 201
 202 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFaceUri::createFastChildContext(
 203         sal_Int32 nElement,
 204         const css::uno::Reference< css::xml::sax::XFastAttributeList > & /*xAttrList*/ )
 205 {
 206     if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_FORMAT) )
 207         return new XMLFontStyleContextFontFaceFormat( GetImport(), *this );
 208     else if( nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA) )
 209     {
 210         assert(linkPath.isEmpty());
 211         if( linkPath.isEmpty() )
 212         {
 213             mxBase64Stream.set( new comphelper::OSequenceOutputStream( maFontData ) );
 214             if( mxBase64Stream.is() )
 215                 return new XMLBase64ImportContext( GetImport(), mxBase64Stream );
 216         }
 217     }
 218     else
 219         XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
 220     return nullptr;
 221 }
 222
 223 void XMLFontStyleContextFontFaceUri::SetAttribute( sal_Int32 nElement,
 224     const OUString& rValue )
 225 {
 226     if( nElement == XML_ELEMENT(XLINK, XML_HREF) )
 227         linkPath = rValue;
 228     else
 229         SvXMLStyleContext::SetAttribute( nElement, rValue );
 230 }
 231
 232 void XMLFontStyleContextFontFaceUri::SetFormat( const OUString& rFormat )
 233 {
 234     format = rFormat;
 235 }
 236
 237 // the CSS2 standard ( http://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#referencing )
 238 // defines these format strings.
 239 const char OPENTYPE_FORMAT[] = "opentype";
 240 const char TRUETYPE_FORMAT[] = "truetype";
 241 const char EOT_FORMAT[]      = "embedded-opentype";
 242
 243 void XMLFontStyleContextFontFaceUri::endFastElement(sal_Int32 )
 244 {
 245     if( ( linkPath.getLength() == 0 ) && ( !maFontData.hasElements() ) )
 246     {
 247         SAL_WARN( "xmloff", "svg:font-face-uri tag with no link or base64 data; ignoring." );
 248         return;
 249     }
 250     bool eot;
 251     // Assume by default that the font is not compressed.
 252     if( format.getLength() == 0
 253         || format == OPENTYPE_FORMAT
 254         || format == TRUETYPE_FORMAT )
 255     {
 256         eot = false;
 257     }
 258     else if( format == EOT_FORMAT )
 259     {
 260         eot = true;
 261     }
 262     else
 263     {
 264         SAL_WARN( "xmloff", "Unknown format of embedded font; assuming TTF." );
 265         eot = false;
 266     }
 267     if ( !maFontData.hasElements() )
 268         handleEmbeddedFont( linkPath, eot );
 269     else
 270         handleEmbeddedFont( maFontData, eot );
 271 }
 272
 273 void XMLFontStyleContextFontFaceUri::handleEmbeddedFont( const OUString& url, bool eot )
 274 {
 275     if( GetImport().embeddedFontAlreadyProcessed( url ))
 276     {
 277         GetImport().NotifyContainsEmbeddedFont();
 278         return;
 279     }
 280     OUString fontName = font.familyName();
 281     // If there's any giveMeStreamForThisURL(), then it's well-hidden for me to find it.
 282     if( GetImport().IsPackageURL( url ))
 283     {
 284         uno::Reference< embed::XStorage > storage;
 285         storage.set( GetImport().GetSourceStorage(), UNO_SET_THROW );
 286         if( url.indexOf( '/' ) > -1 ) // TODO what if more levels?
 287             storage.set( storage->openStorageElement( url.copy( 0, url.indexOf( '/' )),
 288                 ::embed::ElementModes::READ ), uno::UNO_SET_THROW );
 289         uno::Reference< io::XInputStream > inputStream;
 290         inputStream.set( storage->openStreamElement( url.copy( url.indexOf( '/' ) + 1 ), ::embed::ElementModes::READ ),
 291             UNO_QUERY_THROW );
 292         if (GetImport().addEmbeddedFont(inputStream, fontName, u"?", std::vector< unsigned char >(), eot))
 293             GetImport().NotifyContainsEmbeddedFont();
 294         inputStream->closeInput();
 295     }
 296     else
 297         SAL_WARN( "xmloff", "External URL for font file not handled." );
 298 }
 299
 300 void XMLFontStyleContextFontFaceUri::handleEmbeddedFont( const ::css::uno::Sequence< sal_Int8 >& rData, const bool eot )
 301 {
 302     const uno::Reference< io::XInputStream > xInput( new comphelper::SequenceInputStream( rData ) );
 303     const OUString fontName = font.familyName();
 304     if (GetImport().addEmbeddedFont(xInput, fontName, u"?", std::vector< unsigned char >(), eot))
 305         GetImport().NotifyContainsEmbeddedFont();
 306     xInput->closeInput();
 307 }
 308
 309 SvXMLStyleContext *XMLFontStylesContext::CreateStyleChildContext(
 310         sal_Int32 nElement,
 311         const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList )
 312 {
 313     if( nElement == XML_ELEMENT(STYLE, XML_FONT_FACE) )
 314     {
 315         return new XMLFontStyleContextFontFace( GetImport(), *this );
 316     }
 317     return SvXMLStylesContext::CreateStyleChildContext( nElement, xAttrList );
 318 }
 319
 320
 321 XMLFontStylesContext::XMLFontStylesContext( SvXMLImport& rImport,
 322         rtl_TextEncoding eDfltEnc ) :
 323     SvXMLStylesContext( rImport ),
 324     m_pFamilyNameHdl( new XMLFontFamilyNamePropHdl ),
 325     m_pFamilyHdl( new XMLFontFamilyPropHdl ),
 326     m_pPitchHdl( new XMLFontPitchPropHdl ),
 327     m_pEncHdl( new XMLFontEncodingPropHdl ),
 328     m_eDefaultEncoding( eDfltEnc )
 329 {
 330 }
 331
 332 XMLFontStylesContext::~XMLFontStylesContext() {}
 333
 334 bool XMLFontStylesContext::FillProperties( const OUString& rName,
 335                          ::std::vector< XMLPropertyState > &rProps,
 336                          sal_Int32 nFamilyNameIdx,
 337                          sal_Int32 nStyleNameIdx,
 338                          sal_Int32 nFamilyIdx,
 339                          sal_Int32 nPitchIdx,
 340                          sal_Int32 nCharsetIdx ) const
 341 {
 342     const SvXMLStyleContext* pStyle = FindStyleChildContext( XML_STYLE_FAMILY_FONT, rName, true );
 343     const XMLFontStyleContextFontFace *pFontStyle = dynamic_cast<const XMLFontStyleContextFontFace*>(pStyle);// use temp var, PTR_CAST is a bad macro, FindStyleChildContext will be called twice
 344     if( pFontStyle )
 345         pFontStyle->FillProperties( rProps, nFamilyNameIdx, nStyleNameIdx,
 346                                     nFamilyIdx, nPitchIdx, nCharsetIdx );
 347     return nullptr != pFontStyle;
 348 }
 349
 350 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */