svx/source/xml/xmlxtimp.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 <tools/urlobj.hxx>
  21 #include <com/sun/star/document/XGraphicStorageHandler.hpp>
  22 #include <com/sun/star/embed/ElementModes.hpp>
  23 #include <com/sun/star/container/XNameContainer.hpp>
  24 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  25 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  26 #include <com/sun/star/drawing/LineDash.hpp>
  27 #include <com/sun/star/awt/Gradient2.hpp>
  28 #include <com/sun/star/awt/XBitmap.hpp>
  29 #include <com/sun/star/awt/ColorStop.hpp>
  30 #include <com/sun/star/drawing/Hatch.hpp>
  31 #include <com/sun/star/io/XSeekable.hpp>
  32 #include <comphelper/processfactory.hxx>
  33 #include <comphelper/storagehelper.hxx>
  34 #include <sax/tools/converter.hxx>
  35 #include <sfx2/docfile.hxx>
  36 #include <utility>
  37 #include <xmloff/xmlnamespace.hxx>
  38 #include <xmloff/namespacemap.hxx>
  39
  40 #include <xmloff/xmltoken.hxx>
  41 #include <xmloff/DashStyle.hxx>
  42 #include <xmloff/GradientStyle.hxx>
  43 #include <xmloff/HatchStyle.hxx>
  44 #include <xmloff/ImageStyle.hxx>
  45 #include <xmloff/MarkerStyle.hxx>
  46 #include <xmloff/xmlictxt.hxx>
  47 #include <svx/xmlgrhlp.hxx>
  48
  49 #include <xmlxtimp.hxx>
  50 #include <comphelper/sequence.hxx>
  51 #include <comphelper/diagnose_ex.hxx>
  52
  53 using namespace com::sun::star;
  54 using namespace com::sun::star::container;
  55 using namespace com::sun::star::document;
  56 using namespace com::sun::star::uno;
  57 using namespace com::sun::star::awt;
  58 using namespace com::sun::star::lang;
  59 using namespace com::sun::star::xml::sax;
  60 using namespace ::xmloff::token;
  61 using namespace cppu;
  62
  63 namespace {
  64
  65 enum class SvxXMLTableImportContextEnum { Color, Marker, Dash, Hatch, Gradient, Bitmap };
  66
  67 class SvxXMLTableImportContext : public SvXMLImportContext
  68 {
  69 public:
  70     SvxXMLTableImportContext( SvXMLImport& rImport, SvxXMLTableImportContextEnum eContext, uno::Reference< XNameContainer > xTable,
  71         bool bOOoFormat );
  72
  73     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL
  74         createFastChildContext(sal_Int32 Element,
  75             const css::uno::Reference< css::xml::sax::XFastAttributeList > & Attribs) override;
  76
  77 protected:
  78     static void importColor( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName );
  79     void importMarker( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName );
  80     void importDash( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName );
  81     void importHatch( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName );
  82     void importBitmap( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName );
  83
  84 private:
  85     uno::Reference< XNameContainer > mxTable;
  86     SvxXMLTableImportContextEnum meContext;
  87     bool mbOOoFormat;
  88 };
  89
  90 }
  91
  92 SvxXMLTableImportContext::SvxXMLTableImportContext( SvXMLImport& rImport, SvxXMLTableImportContextEnum eContext, uno::Reference< XNameContainer > xTable, bool bOOoFormat )
  93 : SvXMLImportContext( rImport ), mxTable(std::move( xTable )), meContext( eContext ),
  94     mbOOoFormat( bOOoFormat )
  95 {
  96 }
  97
  98 namespace
  99 {
 100     // MCGR: Helper ImportContext to be able to parse sub-content
 101     // entries like XMLGradientStopContext which are allowed now
 102     // for importing Gradients
 103     class XMLGradientHelperContext : public SvXMLImportContext
 104     {
 105     private:
 106         uno::Reference< XNameContainer > mxTable;
 107         css::uno::Any          maAny;
 108         OUString               maStrName;
 109         std::vector<css::awt::ColorStop> maColorStopVec;
 110
 111     public:
 112         XMLGradientHelperContext(
 113             SvXMLImport& rImport,
 114             const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
 115             const css::uno::Reference< XNameContainer >& rxTable);
 116         virtual ~XMLGradientHelperContext() override;
 117         virtual css::uno::Reference<css::xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
 118             sal_Int32 nElement,
 119             const css::uno::Reference<css::xml::sax::XFastAttributeList>& AttrList) override;
 120         virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
 121     };
 122
 123     XMLGradientHelperContext::XMLGradientHelperContext(
 124         SvXMLImport& rImport,
 125         const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
 126         const uno::Reference< XNameContainer >& rxTable)
 127     :   SvXMLImportContext(rImport),
 128         mxTable(rxTable)
 129     {
 130         try
 131         {
 132             // Import GradientStyle
 133             XMLGradientStyleImport aGradientStyle( GetImport() );
 134             aGradientStyle.importXML( xAttrList, maAny, maStrName );
 135         }
 136         catch (const uno::Exception&)
 137         {
 138             DBG_UNHANDLED_EXCEPTION("svx");
 139         }
 140     }
 141
 142     XMLGradientHelperContext::~XMLGradientHelperContext()
 143     {
 144         // if GradientStyle was imported, add to List
 145         if( !maStrName.isEmpty() && maAny.hasValue() )
 146         {
 147             if( mxTable->hasByName( maStrName ) )
 148             {
 149                 mxTable->replaceByName( maStrName, maAny );
 150             }
 151             else
 152             {
 153                 mxTable->insertByName( maStrName, maAny );
 154             }
 155         }
 156     }
 157
 158     css::uno::Reference<css::xml::sax::XFastContextHandler> XMLGradientHelperContext::createFastChildContext(
 159             sal_Int32 nElement,
 160             const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList)
 161     {
 162         // be prepared & import GradientStop entries
 163         if (nElement == XML_ELEMENT(LO_EXT, xmloff::token::XML_GRADIENT_STOP))
 164         {
 165             return new XMLGradientStopContext(GetImport(), nElement, xAttrList, maColorStopVec);
 166         }
 167
 168         return nullptr;
 169     }
 170
 171     void XMLGradientHelperContext::endFastElement(sal_Int32 )
 172     {
 173         // correcting invalid StopOffset values is done at the model. Therefore we import them here
 174         // without any change.
 175         if (!maColorStopVec.empty())
 176         {
 177             awt::Gradient2 aGradient;
 178             maAny >>= aGradient;
 179             aGradient.ColorStops = comphelper::containerToSequence(maColorStopVec);
 180             maAny <<= aGradient;
 181         }
 182     }
 183 }
 184
 185 css::uno::Reference< css::xml::sax::XFastContextHandler >
 186         SvxXMLTableImportContext::createFastChildContext(sal_Int32 nElement,
 187             const css::uno::Reference< css::xml::sax::XFastAttributeList > & rAttrList)
 188 {
 189     if( !(IsTokenInNamespace(nElement, XML_NAMESPACE_DRAW) ||
 190           IsTokenInNamespace(nElement, XML_NAMESPACE_DRAW_OOO) ))
 191             return nullptr;
 192
 193     std::vector<std::pair<sal_Int32, OString>> aTmpAttrList;
 194     for (auto& aIter : sax_fastparser::castToFastAttributeList( rAttrList ))
 195         aTmpAttrList.push_back({aIter.getToken(), OString(aIter.toCString())});
 196     if( mbOOoFormat &&
 197          (SvxXMLTableImportContextEnum::Dash == meContext || SvxXMLTableImportContextEnum::Hatch == meContext ||
 198          SvxXMLTableImportContextEnum::Bitmap == meContext) )
 199     {
 200         for( auto & aIter : aTmpAttrList )
 201         {
 202             sal_Int32 aLocalAttr = aIter.first & TOKEN_MASK;
 203             if( aIter.first == XML_ELEMENT(XLINK, XML_HREF) &&
 204                 SvxXMLTableImportContextEnum::Bitmap == meContext )
 205             {
 206                 OString& rValue = aIter.second;
 207                 if( !rValue.isEmpty() && '#' == rValue[0] )
 208                     rValue = rValue.copy( 1 );
 209             }
 210             else if( (IsTokenInNamespace(aIter.first, XML_NAMESPACE_DRAW) || IsTokenInNamespace(aIter.first, XML_NAMESPACE_DRAW_OOO)) &&
 211                       ( ( SvxXMLTableImportContextEnum::Dash == meContext &&
 212                           ( aLocalAttr == XML_DOTS1_LENGTH ||
 213                             aLocalAttr == XML_DOTS2_LENGTH ||
 214                             aLocalAttr == XML_DISTANCE ) ) ||
 215                         ( SvxXMLTableImportContextEnum::Hatch == meContext &&
 216                           ( aLocalAttr == XML_DISTANCE ) ) ) )
 217             {
 218                 OString& rValue = aIter.second;
 219                 sal_Int32 nPos = rValue.getLength();
 220                 while( nPos && rValue[nPos-1] <= ' ' )
 221                     --nPos;
 222                 if( nPos > 2 &&
 223                     ('c'==rValue[nPos-2] || 'C'==rValue[nPos-2]) &&
 224                     ('h'==rValue[nPos-1] || 'H'==rValue[nPos-1]) )
 225                 {
 226                     rValue = rValue.copy( 0, nPos-2 );
 227                 }
 228             }
 229         }
 230     }
 231
 232     if (nElement == XML_ELEMENT(DRAW, XML_GRADIENT))
 233     {
 234         // MCGR: for Gradients, no longer use fixed import but use an own
 235         // ImportContext to be able to import now possible sub-entries like
 236         // ColorStop entries
 237         return new XMLGradientHelperContext( GetImport(), rAttrList, mxTable );
 238     }
 239
 240     try
 241     {
 242         rtl::Reference<sax_fastparser::FastAttributeList> xFastList = new sax_fastparser::FastAttributeList(nullptr);
 243         for (const auto& aIter : aTmpAttrList)
 244             xFastList->add(aIter.first, aIter.second);
 245
 246         Any aAny;
 247         OUString aName;
 248
 249         switch( meContext )
 250         {
 251         case SvxXMLTableImportContextEnum::Color:
 252             importColor( xFastList, aAny, aName );
 253             break;
 254         case SvxXMLTableImportContextEnum::Marker:
 255             importMarker( xFastList, aAny, aName  );
 256             break;
 257         case SvxXMLTableImportContextEnum::Dash:
 258             importDash( xFastList, aAny, aName  );
 259             break;
 260         case SvxXMLTableImportContextEnum::Hatch:
 261             importHatch( xFastList, aAny, aName  );
 262             break;
 263         case SvxXMLTableImportContextEnum::Bitmap:
 264             importBitmap( xFastList, aAny, aName  );
 265             break;
 266         default:
 267             // SvxXMLTableImportContextEnum::Gradient
 268             // is no longer imported as 'fixed content'
 269             // but dynamically using an own ImportContext
 270             break;
 271         }
 272
 273         if( !aName.isEmpty() && aAny.hasValue() )
 274         {
 275             if( mxTable->hasByName( aName ) )
 276             {
 277                 mxTable->replaceByName( aName, aAny );
 278             }
 279             else
 280             {
 281                 mxTable->insertByName( aName, aAny );
 282             }
 283         }
 284     }
 285     catch (const uno::Exception&)
 286     {
 287         DBG_UNHANDLED_EXCEPTION("svx");
 288     }
 289     return new SvXMLImportContext( GetImport() );
 290 }
 291
 292 void SvxXMLTableImportContext::importColor( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName )
 293 {
 294     for (auto& aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
 295     {
 296         switch (aIter.getToken())
 297         {
 298             case XML_ELEMENT(DRAW, XML_NAME):
 299             case XML_ELEMENT(DRAW_OOO, XML_NAME):
 300                 rName = aIter.toString();
 301                 break;
 302             case XML_ELEMENT(DRAW, XML_COLOR):
 303             case XML_ELEMENT(DRAW_OOO, XML_COLOR):
 304             {
 305                 sal_Int32 nColor(0);
 306                 ::sax::Converter::convertColor(nColor, aIter.toView());
 307                 rAny <<= nColor;
 308                 break;
 309             }
 310             default:
 311                 XMLOFF_WARN_UNKNOWN("xmloff", aIter);
 312         }
 313     }
 314 }
 315
 316 void SvxXMLTableImportContext::importMarker( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName )
 317 {
 318     try
 319     {
 320         XMLMarkerStyleImport aMarkerStyle( GetImport() );
 321         aMarkerStyle.importXML( xAttrList, rAny, rName );
 322     }
 323     catch (const Exception&)
 324     {
 325         TOOLS_WARN_EXCEPTION("svx", "");
 326     }
 327 }
 328
 329 void SvxXMLTableImportContext::importDash( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName )
 330 {
 331     try
 332     {
 333         XMLDashStyleImport aDashStyle( GetImport() );
 334         aDashStyle.importXML( xAttrList, rAny, rName );
 335     }
 336     catch (const Exception&)
 337     {
 338         TOOLS_WARN_EXCEPTION("svx", "");
 339     }
 340 }
 341
 342 void SvxXMLTableImportContext::importHatch( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName )
 343 {
 344     try
 345     {
 346         XMLHatchStyleImport aHatchStyle( GetImport() );
 347         aHatchStyle.importXML( xAttrList, rAny, rName );
 348     }
 349     catch (const Exception&)
 350     {
 351         TOOLS_WARN_EXCEPTION("svx", "");
 352     }
 353 }
 354
 355 void SvxXMLTableImportContext::importBitmap( const uno::Reference< XFastAttributeList >& xAttrList, Any& rAny, OUString& rName )
 356 {
 357     try
 358     {
 359         uno::Any aGraphicAny;
 360         XMLImageStyle::importXML(xAttrList, aGraphicAny, rName, GetImport());
 361         if (aGraphicAny.has<uno::Reference<graphic::XGraphic>>())
 362         {
 363             auto xGraphic = aGraphicAny.get<uno::Reference<graphic::XGraphic>>();
 364             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 365             if (xBitmap.is())
 366                 rAny <<= xBitmap;
 367         }
 368     }
 369     catch (const Exception&)
 370     {
 371         TOOLS_WARN_EXCEPTION("svx", "");
 372     }
 373 }
 374
 375
 376 SvxXMLXTableImport::SvxXMLXTableImport(
 377     const css::uno::Reference< css::uno::XComponentContext >& rContext,
 378     const uno::Reference< XNameContainer > & rTable,
 379     uno::Reference<XGraphicStorageHandler> const & xGraphicStorageHandler)
 380 :   SvXMLImport(rContext, "", SvXMLImportFlags::NONE),
 381     mrTable( rTable )
 382 {
 383     SetGraphicStorageHandler(xGraphicStorageHandler);
 384
 385     GetNamespaceMap().Add( GetXMLToken(XML_NP_OOO), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO);
 386     GetNamespaceMap().Add( GetXMLToken(XML_NP_OFFICE), GetXMLToken(XML_N_OFFICE), XML_NAMESPACE_OFFICE);
 387     GetNamespaceMap().Add( GetXMLToken(XML_NP_DRAW), GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW);
 388     GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK);
 389
 390     GetNamespaceMap().Add( "__ooo", GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
 391     GetNamespaceMap().Add( "__xlink", GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
 392
 393     // OOo namespaces for reading OOo 1.1 files
 394     GetNamespaceMap().Add( "___office",
 395                         GetXMLToken(XML_N_OFFICE_OOO),
 396                         XML_NAMESPACE_OFFICE );
 397     GetNamespaceMap().Add( "___draw",
 398                         GetXMLToken(XML_N_DRAW_OOO),
 399                         XML_NAMESPACE_DRAW );
 400     GetNamespaceMap().Add( "___loext",
 401                         GetXMLToken(XML_N_LO_EXT),
 402                         XML_NAMESPACE_LO_EXT);
 403 }
 404
 405 SvxXMLXTableImport::~SvxXMLXTableImport() noexcept
 406 {
 407 }
 408
 409 static void openStorageStream( xml::sax::InputSource *pParserInput,
 410                                rtl::Reference<SvXMLGraphicHelper>& rxGraphicHelper,
 411                                const uno::Reference < embed::XStorage >& xStorage )
 412 {
 413     uno::Reference < io::XStream > xIStm( xStorage->openStreamElement( "Content.xml", embed::ElementModes::READ ), uno::UNO_SET_THROW );
 414     pParserInput->aInputStream = xIStm->getInputStream();
 415     rxGraphicHelper = SvXMLGraphicHelper::Create( xStorage, SvXMLGraphicHelperMode::Read );
 416 }
 417
 418 bool SvxXMLXTableImport::load( const OUString &rPath, const OUString &rReferer,
 419                                const uno::Reference < embed::XStorage > &xStorage,
 420                                const uno::Reference< XNameContainer >& xTable,
 421                                bool *bOptLoadedFromStorage ) noexcept
 422 {
 423     bool bRet = true;
 424     rtl::Reference<SvXMLGraphicHelper> xGraphicHelper;
 425
 426     INetURLObject aURLObj( rPath );
 427     bool bUseStorage = aURLObj.GetProtocol() == INetProtocol::NotValid; // a relative path
 428
 429     try
 430     {
 431         uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
 432
 433         xml::sax::InputSource aParserInput;
 434         comphelper::LifecycleProxy aNasty;
 435
 436         if( !bUseStorage || !xStorage.is() )
 437         {
 438             SfxMedium aMedium( rPath, rReferer, StreamMode::READ | StreamMode::NOCREATE );
 439             aParserInput.sSystemId = aMedium.GetName();
 440
 441             if( aMedium.IsStorage() )
 442             {
 443                 uno::Reference < embed::XStorage > xMediumStorage( aMedium.GetStorage( false ), uno::UNO_SET_THROW );
 444                 openStorageStream( &aParserInput, xGraphicHelper, xMediumStorage );
 445             }
 446             else
 447                 aParserInput.aInputStream = aMedium.GetInputStream();
 448         }
 449         else // relative URL into a storage
 450         {
 451             uno::Reference< embed::XStorage > xSubStorage;
 452             try
 453             {
 454                 xSubStorage = comphelper::OStorageHelper::GetStorageAtPath(
 455                         xStorage, rPath, embed::ElementModes::READ, aNasty );
 456             }
 457             catch (const uno::Exception&)
 458             {
 459             }
 460             if( xSubStorage.is() )
 461                 openStorageStream( &aParserInput, xGraphicHelper, xSubStorage );
 462             else
 463             {
 464                 css::uno::Reference< css::io::XStream > xStream = comphelper::OStorageHelper::GetStreamAtPath(
 465                         xStorage, rPath, embed::ElementModes::READ, aNasty );
 466                 if( !xStream.is() )
 467                     return false;
 468                 aParserInput.aInputStream = xStream->getInputStream();
 469             }
 470             if( bOptLoadedFromStorage )
 471                 *bOptLoadedFromStorage = true;
 472         }
 473
 474         uno::Reference<XGraphicStorageHandler> xGraphicStorageHandler;
 475         if (xGraphicHelper.is())
 476             xGraphicStorageHandler = xGraphicHelper.get();
 477
 478         try
 479         {
 480             uno::Reference< io::XSeekable > xSeek( aParserInput.aInputStream, uno::UNO_QUERY_THROW );
 481             xSeek->seek( 0 );
 482         }
 483         catch (const uno::Exception&)
 484         {
 485         }
 486
 487         rtl::Reference<SvxXMLXTableImport> xImport(new SvxXMLXTableImport(xContext, xTable, xGraphicStorageHandler));
 488         xImport->parseStream( aParserInput );
 489
 490         if( xGraphicHelper )
 491             xGraphicHelper->dispose();
 492     }
 493     catch (...)
 494     {
 495 //      thrown each time you load a document with property tables that are not
 496 //      on the current machine. FIXME: would be better to check a file exists
 497 //      before importing ...
 498         bRet = false;
 499     }
 500
 501     return bRet;
 502 }
 503
 504 SvXMLImportContext *SvxXMLXTableImport::CreateFastContext( sal_Int32 nElement,
 505         const ::css::uno::Reference< ::css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
 506 {
 507     if( IsTokenInNamespace(nElement, XML_NAMESPACE_OOO) ||
 508         IsTokenInNamespace(nElement, XML_NAMESPACE_OFFICE) ||
 509         IsTokenInNamespace(nElement, XML_NAMESPACE_OFFICE_OOO) )
 510     {
 511         bool bOOoFormat = IsTokenInNamespace(nElement, XML_NAMESPACE_OFFICE) ||
 512                           IsTokenInNamespace(nElement, XML_NAMESPACE_OFFICE_OOO);
 513         Type aType = mrTable->getElementType();
 514         sal_Int32 nToken = nElement & TOKEN_MASK;
 515
 516         if ( nToken == XML_COLOR_TABLE )
 517         {
 518             if( aType == ::cppu::UnoType<sal_Int32>::get() )
 519                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Color, mrTable, bOOoFormat );
 520         }
 521         else if ( nToken == XML_MARKER_TABLE )
 522         {
 523             if( aType == cppu::UnoType<drawing::PolyPolygonBezierCoords>::get())
 524                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Marker, mrTable, bOOoFormat );
 525         }
 526         else if ( nToken == XML_DASH_TABLE )
 527         {
 528             if( aType == cppu::UnoType<drawing::LineDash>::get())
 529                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Dash, mrTable, bOOoFormat );
 530         }
 531         else if ( nToken == XML_HATCH_TABLE )
 532         {
 533             if( aType == cppu::UnoType<drawing::Hatch>::get())
 534                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Hatch, mrTable, bOOoFormat );
 535         }
 536         else if ( nToken == XML_GRADIENT_TABLE )
 537         {
 538             if( aType == cppu::UnoType<awt::Gradient>::get())
 539                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Gradient, mrTable, bOOoFormat );
 540         }
 541         else if ( nToken == XML_BITMAP_TABLE )
 542         {
 543             if( aType == ::cppu::UnoType<awt::XBitmap>::get())
 544                 return new SvxXMLTableImportContext( *this, SvxXMLTableImportContextEnum::Bitmap, mrTable, bOOoFormat );
 545         }
 546     }
 547
 548     return nullptr;
 549 }
 550
 551 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */