svgio/source/svguno/xsvgparser.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 <sal/config.h>
  21
  22 #include <com/sun/star/graphic/XSvgParser.hpp>
  23 #include <com/sun/star/lang/XServiceInfo.hpp>
  24 #include <com/sun/star/lang/XInitialization.hpp>
  25 #include <cppuhelper/implbase2.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <comphelper/sequence.hxx>
  28 #include <com/sun/star/xml/sax/XParser.hpp>
  29 #include <com/sun/star/xml/sax/Parser.hpp>
  30 #include <com/sun/star/xml/sax/InputSource.hpp>
  31 #include <drawinglayer/geometry/viewinformation2d.hxx>
  32 #include <svgdocumenthandler.hxx>
  33
  34 #include "xsvgparser.hxx"
  35
  36 using namespace ::com::sun::star;
  37
  38 namespace svgio
  39 {
  40     namespace svgreader
  41     {
  42         class XSvgParser : public ::cppu::WeakAggImplHelper2< graphic::XSvgParser, lang::XServiceInfo >
  43         {
  44         private:
  45             uno::Reference< uno::XComponentContext > context_;
  46
  47         protected:
  48         public:
  49             explicit XSvgParser(
  50                 uno::Reference< uno::XComponentContext > const & context);
  51             XSvgParser(const XSvgParser&) = delete;
  52             XSvgParser& operator=(const XSvgParser&) = delete;
  53
  54             // XSvgParser
  55             virtual uno::Sequence< uno::Reference< ::graphic::XPrimitive2D > > SAL_CALL getDecomposition(
  56                 const uno::Reference< ::io::XInputStream >& xSVGStream,
  57                 const OUString& aAbsolutePath) override;
  58
  59             // XServiceInfo
  60             virtual OUString SAL_CALL getImplementationName() override;
  61             virtual sal_Bool SAL_CALL supportsService(const OUString&) override;
  62             virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
  63         };
  64     } // end of namespace svgreader
  65 } // end of namespace svgio
  66
  67 // uno functions
  68 namespace svgio
  69 {
  70     namespace svgreader
  71     {
  72         uno::Sequence< OUString > XSvgParser_getSupportedServiceNames()
  73         {
  74             return uno::Sequence< OUString > { "com.sun.star.graphic.SvgTools" };
  75         }
  76
  77         OUString XSvgParser_getImplementationName()
  78         {
  79             return OUString( "svgio::svgreader::XSvgParser" );
  80         }
  81
  82         uno::Reference< uno::XInterface > XSvgParser_createInstance(const uno::Reference< uno::XComponentContext >& context)
  83         {
  84             return static_cast< ::cppu::OWeakObject* >(new XSvgParser(context));
  85         }
  86     } // end of namespace svgreader
  87 } // end of namespace svgio
  88
  89 namespace svgio
  90 {
  91     namespace svgreader
  92     {
  93         XSvgParser::XSvgParser(
  94             uno::Reference< uno::XComponentContext > const & context):
  95             context_(context)
  96         {
  97         }
  98
  99         uno::Sequence< uno::Reference< ::graphic::XPrimitive2D > > XSvgParser::getDecomposition(
 100             const uno::Reference< ::io::XInputStream >& xSVGStream,
 101             const OUString& aAbsolutePath )
 102         {
 103             drawinglayer::primitive2d::Primitive2DContainer aRetval;
 104
 105             if(xSVGStream.is())
 106             {
 107                 // local document handler
 108                 SvgDocHdl* pSvgDocHdl = new SvgDocHdl(aAbsolutePath);
 109                 uno::Reference< xml::sax::XDocumentHandler > xSvgDocHdl(pSvgDocHdl);
 110
 111                 try
 112                 {
 113                     // prepare ParserInputSrouce
 114                     xml::sax::InputSource myInputSource;
 115                     myInputSource.aInputStream = xSVGStream;
 116
 117                     // get parser
 118                     uno::Reference< xml::sax::XParser > xParser(
 119                         xml::sax::Parser::create(context_));
 120                     // fdo#60471 need to enable internal entities because
 121                     // certain ... popular proprietary products write SVG files
 122                     // that use entities to define XML namespaces.
 123                     uno::Reference<lang::XInitialization> const xInit(xParser,
 124                             uno::UNO_QUERY_THROW);
 125                     uno::Sequence<uno::Any> args(1);
 126                     args[0] <<= OUString("DoSmeplease");
 127                     xInit->initialize(args);
 128
 129                     // connect parser and filter
 130                     xParser->setDocumentHandler(xSvgDocHdl);
 131
 132                     // finally, parse the stream to a hierarchy of
 133                     // SVGGraphicPrimitive2D which will be embedded to the
 134                     // primitive sequence. Their decompositions will in the
 135                     // end create local low-level primitives, thus SVG will
 136                     // be processable from all our processors
 137                     xParser->parseStream(myInputSource);
 138                 }
 139                 catch(const uno::Exception& e)
 140                 {
 141                     SAL_WARN( "svg", "Parse error! : " << e);
 142                 }
 143
 144                 // decompose to primitives
 145                 const SvgNodeVector& rResults = pSvgDocHdl->getSvgDocument().getSvgNodeVector();
 146                 const sal_uInt32 nCount(rResults.size());
 147
 148                 for(sal_uInt32 a(0); a < nCount; a++)
 149                 {
 150                     SvgNode* pCandidate = rResults[a];
 151
 152                     if(Display_none != pCandidate->getDisplay())
 153                     {
 154                         pCandidate->decomposeSvgNode(aRetval, false);
 155                     }
 156                 }
 157             }
 158             else
 159             {
 160                 OSL_ENSURE(false, "Invalid stream (!)");
 161             }
 162
 163             return comphelper::containerToSequence(aRetval);
 164         }
 165
 166         OUString SAL_CALL XSvgParser::getImplementationName()
 167         {
 168             return XSvgParser_getImplementationName();
 169         }
 170
 171         sal_Bool SAL_CALL XSvgParser::supportsService(const OUString& rServiceName)
 172         {
 173             return cppu::supportsService(this, rServiceName);
 174         }
 175
 176         uno::Sequence< OUString > SAL_CALL XSvgParser::getSupportedServiceNames()
 177         {
 178             return XSvgParser_getSupportedServiceNames();
 179         }
 180
 181     } // end of namespace svgreader
 182 } // end of namespace svgio
 183
 184 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */