oox/source/shape/ShapeContextHandler.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 <com/sun/star/beans/XPropertySet.hpp>
  21 #include <com/sun/star/drawing/XGluePointsSupplier.hpp>
  22 #include <com/sun/star/container/XIdentifierContainer.hpp>
  23 #include <com/sun/star/xml/dom/XDocument.hpp>
  24 #include <com/sun/star/xml/sax/XFastSAXSerializable.hpp>
  25
  26 #include <oox/shape/ShapeContextHandler.hxx>
  27 #include <oox/shape/ShapeDrawingFragmentHandler.hxx>
  28 #include "LockedCanvasContext.hxx"
  29 #include "WordprocessingCanvasContext.hxx"
  30 #include "WpsContext.hxx"
  31 #include "WpgContext.hxx"
  32 #include <basegfx/matrix/b2dhommatrix.hxx>
  33 #include <oox/vml/vmldrawingfragment.hxx>
  34 #include <oox/vml/vmlshape.hxx>
  35 #include <oox/vml/vmlshapecontainer.hxx>
  36 #include <oox/shape/ShapeFilterBase.hxx>
  37 #include <oox/token/namespaces.hxx>
  38 #include <oox/token/tokens.hxx>
  39 #include <oox/drawingml/theme.hxx>
  40 #include <oox/drawingml/themefragmenthandler.hxx>
  41 #include <svx/svdogrp.hxx>
  42 #include <svx/svdoedge.hxx>
  43 #include <svx/svdobj.hxx>
  44
  45 #include <drawingml/connectorhelper.hxx>
  46
  47 #include <memory>
  48 #include <utility>
  49
  50 using namespace ::com::sun::star;
  51
  52 namespace oox::shape {
  53 using namespace core;
  54 using namespace drawingml;
  55
  56 ShapeContextHandler::ShapeContextHandler(rtl::Reference<ShapeFilterBase> xFilterBase) :
  57   m_bFullWPGSUpport(false),
  58   mxShapeFilterBase(std::move(xFilterBase))
  59
  60 {
  61 }
  62
  63 ShapeContextHandler::~ShapeContextHandler()
  64 {
  65 }
  66
  67 uno::Reference<xml::sax::XFastContextHandler> ShapeContextHandler::getLockedCanvasContext(sal_Int32 nElement)
  68 {
  69     if (!mxLockedCanvasContext.is())
  70     {
  71         FragmentHandler2Ref rFragmentHandler(new ShapeFragmentHandler(*mxShapeFilterBase, msRelationFragmentPath));
  72
  73         switch (nElement & 0xffff)
  74         {
  75             case XML_lockedCanvas:
  76                 mxLockedCanvasContext.set(new LockedCanvasContext(*rFragmentHandler));
  77                 break;
  78             default:
  79                 break;
  80         }
  81     }
  82
  83     return static_cast<ContextHandler *>(mxLockedCanvasContext.get());
  84 }
  85
  86 /*
  87  * This method creates new ChartGraphicDataContext Object.
  88  */
  89 uno::Reference<xml::sax::XFastContextHandler> ShapeContextHandler::getChartShapeContext(sal_Int32 nElement)
  90 {
  91     if (!mxChartShapeContext.is())
  92     {
  93         switch (nElement & 0xffff)
  94         {
  95             case XML_chart:
  96             {
  97                 std::unique_ptr<ContextHandler2Helper> pFragmentHandler(
  98                         new ShapeFragmentHandler(*mxShapeFilterBase, msRelationFragmentPath));
  99                 mpShape = std::make_shared<Shape>("com.sun.star.drawing.OLE2Shape" );
 100                 mxChartShapeContext.set(new ChartGraphicDataContext(*pFragmentHandler, mpShape, true));
 101                 break;
 102             }
 103             default:
 104                 break;
 105         }
 106     }
 107
 108     return mxChartShapeContext;
 109 }
 110
 111 uno::Reference<xml::sax::XFastContextHandler> ShapeContextHandler::getWpsContext(sal_Int32 nStartElement, sal_Int32 nElement)
 112 {
 113     if (!mxWpsContext.is())
 114     {
 115         FragmentHandler2Ref rFragmentHandler(new ShapeFragmentHandler(*mxShapeFilterBase, msRelationFragmentPath));
 116         ShapePtr pMasterShape;
 117
 118         uno::Reference<drawing::XShape> xShape;
 119         // No element happens in case of pretty-printed XML, bodyPr is the case when we are called again after <wps:txbx>.
 120         if (!nElement || nElement == WPS_TOKEN(bodyPr))
 121             // Assume that this is just a continuation of the previous shape.
 122             xShape = mxSavedShape;
 123
 124         switch (getBaseToken(nStartElement))
 125         {
 126             case XML_wsp:
 127                 mxWpsContext.set(new WpsContext(
 128                                      *rFragmentHandler,
 129                                      xShape,
 130                                      pMasterShape,
 131                                      std::make_shared<oox::drawingml::Shape>(
 132                                              "com.sun.star.drawing.CustomShape")));
 133                 break;
 134             default:
 135                 break;
 136         }
 137     }
 138
 139     return mxWpsContext;
 140 }
 141
 142 uno::Reference<xml::sax::XFastContextHandler> ShapeContextHandler::getWpgContext(sal_Int32 nElement)
 143 {
 144     if (!mxWpgContext.is())
 145     {
 146         FragmentHandler2Ref rFragmentHandler(new ShapeFragmentHandler(*mxShapeFilterBase, msRelationFragmentPath));
 147
 148         switch (getBaseToken(nElement))
 149         {
 150             case XML_wgp:
 151             {
 152                 mxWpgContext.set(new WpgContext(*rFragmentHandler, oox::drawingml::ShapePtr()));
 153                 mxWpgContext->setFullWPGSupport(m_bFullWPGSUpport);
 154                 break;
 155             }
 156             default:
 157                 break;
 158         }
 159     }
 160
 161     return static_cast<ContextHandler *>(mxWpgContext.get());
 162 }
 163
 164 uno::Reference<xml::sax::XFastContextHandler> const &
 165 ShapeContextHandler::getGraphicShapeContext(::sal_Int32 Element )
 166 {
 167     if (! mxGraphicShapeContext.is())
 168     {
 169         auto pFragmentHandler = std::make_shared<ShapeFragmentHandler>(*mxShapeFilterBase, msRelationFragmentPath);
 170         ShapePtr pMasterShape;
 171
 172         switch (Element & 0xffff)
 173         {
 174             case XML_graphic:
 175                 mpShape = std::make_shared<Shape>("com.sun.star.drawing.GraphicObjectShape" );
 176                 mxGraphicShapeContext.set
 177                 (new GraphicalObjectFrameContext(*pFragmentHandler, pMasterShape, mpShape, true));
 178                 break;
 179             case XML_pic:
 180                 mpShape = std::make_shared<Shape>("com.sun.star.drawing.GraphicObjectShape" );
 181                 mxGraphicShapeContext.set
 182                 (new GraphicShapeContext(*pFragmentHandler, pMasterShape, mpShape));
 183                 break;
 184             default:
 185                 break;
 186         }
 187     }
 188
 189     return mxGraphicShapeContext;
 190 }
 191
 192 uno::Reference<xml::sax::XFastContextHandler>
 193 ShapeContextHandler::getDrawingShapeContext()
 194 {
 195     if (!mxDrawingFragmentHandler.is())
 196     {
 197         mpDrawing = std::make_shared<oox::vml::Drawing>( *mxShapeFilterBase, mxDrawPage, oox::vml::VMLDRAWING_WORD );
 198         mxDrawingFragmentHandler.set
 199            (new oox::vml::DrawingFragment
 200             ( *mxShapeFilterBase, msRelationFragmentPath, *mpDrawing ));
 201     }
 202     else
 203     {
 204         // Reset the handler if fragment path has changed
 205         OUString sHandlerFragmentPath = mxDrawingFragmentHandler->getFragmentPath();
 206         if ( msRelationFragmentPath != sHandlerFragmentPath )
 207         {
 208             mxDrawingFragmentHandler.clear();
 209             mxDrawingFragmentHandler.set
 210                (new oox::vml::DrawingFragment
 211                 ( *mxShapeFilterBase, msRelationFragmentPath, *mpDrawing ));
 212         }
 213     }
 214     return static_cast<ContextHandler *>(mxDrawingFragmentHandler.get());
 215 }
 216
 217 uno::Reference<xml::sax::XFastContextHandler>
 218 ShapeContextHandler::getDiagramShapeContext()
 219 {
 220     if (!mxDiagramShapeContext.is())
 221     {
 222         auto pFragmentHandler = std::make_shared<ShapeFragmentHandler>(*mxShapeFilterBase, msRelationFragmentPath);
 223         mpShape = std::make_shared<Shape>();
 224         mpShape->setSize(maSize);
 225         mxDiagramShapeContext.set(new DiagramGraphicDataContext(*pFragmentHandler, mpShape));
 226     }
 227
 228     return mxDiagramShapeContext;
 229 }
 230
 231 uno::Reference<xml::sax::XFastContextHandler> ShapeContextHandler::getWordprocessingCanvasContext(sal_Int32 nElement)
 232 {
 233     if (!mxWordprocessingCanvasContext.is())
 234     {
 235         FragmentHandler2Ref rFragmentHandler(new ShapeFragmentHandler(*mxShapeFilterBase, msRelationFragmentPath));
 236
 237         switch (getBaseToken(nElement))
 238         {
 239             case XML_wpc:
 240                 mxWordprocessingCanvasContext.set(new WordprocessingCanvasContext(*rFragmentHandler, maSize));
 241                 break;
 242             default:
 243                 break;
 244         }
 245     }
 246
 247     return static_cast<ContextHandler *>(mxWordprocessingCanvasContext.get());
 248 }
 249
 250 uno::Reference<xml::sax::XFastContextHandler>
 251 ShapeContextHandler::getContextHandler(sal_Int32 nElement)
 252 {
 253     uno::Reference<xml::sax::XFastContextHandler> xResult;
 254     const sal_uInt32 nStartToken = getStartToken();
 255
 256     switch (getNamespace( nStartToken ))
 257     {
 258         case NMSP_doc:
 259         case NMSP_vml:
 260             xResult.set(getDrawingShapeContext());
 261             break;
 262         case NMSP_dmlDiagram:
 263             xResult.set(getDiagramShapeContext());
 264             break;
 265         case NMSP_dmlLockedCanvas:
 266             xResult.set(getLockedCanvasContext(nStartToken));
 267             break;
 268         case NMSP_dmlChart:
 269             xResult.set(getChartShapeContext(nStartToken));
 270             break;
 271         case NMSP_wps:
 272             xResult.set(getWpsContext(nStartToken, nElement));
 273             break;
 274         case NMSP_wpg:
 275             xResult.set(getWpgContext(nStartToken));
 276             break;
 277         case NMSP_wpc:
 278             xResult.set(getWordprocessingCanvasContext(nStartToken));
 279             break;
 280         default:
 281             xResult.set(getGraphicShapeContext(nStartToken));
 282             break;
 283     }
 284
 285     return xResult;
 286 }
 287
 288 // css::xml::sax::XFastContextHandler:
 289 void SAL_CALL ShapeContextHandler::startFastElement
 290 (::sal_Int32 Element,
 291  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 292 {
 293     mxShapeFilterBase->filter(maMediaDescriptor);
 294
 295     if (Element == DGM_TOKEN(relIds) || Element == LC_TOKEN(lockedCanvas) || Element == C_TOKEN(chart) ||
 296         Element == WPS_TOKEN(wsp) || Element == WPG_TOKEN(wgp) || Element == OOX_TOKEN(dmlPicture, pic)
 297         || Element == WPC_TOKEN(wpc))
 298     {
 299         // Parse the theme relation, if available; the diagram won't have colors without it.
 300         if (!mpThemePtr && !msRelationFragmentPath.isEmpty())
 301         {
 302             // Get Target for Type = "officeDocument" from _rels/.rels file
 303             // aOfficeDocumentFragmentPath is pointing to "word/document.xml" for docx & to "ppt/presentation.xml" for pptx
 304             FragmentHandlerRef rFragmentHandlerRef(new ShapeFragmentHandler(*mxShapeFilterBase, u"/"_ustr));
 305             OUString aOfficeDocumentFragmentPath = rFragmentHandlerRef->getFragmentPathFromFirstTypeFromOfficeDoc( u"officeDocument" );
 306
 307             // Get the theme DO NOT  use msRelationFragmentPath for getting theme as for a document there is a single theme in document.xml.rels
 308             // and the same is used by header and footer as well.
 309             FragmentHandlerRef rFragmentHandler(new ShapeFragmentHandler(*mxShapeFilterBase, aOfficeDocumentFragmentPath));
 310             OUString aThemeFragmentPath = rFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( u"theme" );
 311
 312             if (!aThemeFragmentPath.isEmpty())
 313             {
 314                 mpThemePtr = std::make_shared<Theme>();
 315                 auto pTheme = std::make_shared<model::Theme>();
 316                 mpThemePtr->setTheme(pTheme);
 317                 uno::Reference<xml::sax::XFastSAXSerializable> xDoc(mxShapeFilterBase->importFragment(aThemeFragmentPath), uno::UNO_QUERY_THROW);
 318                 mxShapeFilterBase->importFragment(new ThemeFragmentHandler(*mxShapeFilterBase, aThemeFragmentPath, *mpThemePtr, *pTheme), xDoc);
 319                 mxShapeFilterBase->setCurrentTheme(mpThemePtr);
 320             }
 321         }
 322         else if (mpThemePtr && !mxShapeFilterBase->getCurrentTheme())
 323         {
 324             mxShapeFilterBase->setCurrentTheme(mpThemePtr);
 325         }
 326
 327         createFastChildContext(Element, Attribs);
 328     }
 329
 330     // Entering VML block (startFastElement() is called for the outermost tag),
 331     // handle possible recursion.
 332     if ( getContextHandler() == getDrawingShapeContext() )
 333         mpDrawing->getShapes().pushMark();
 334
 335     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 336
 337     if (xContextHandler.is())
 338         xContextHandler->startFastElement(Element, Attribs);
 339 }
 340
 341 void SAL_CALL ShapeContextHandler::startUnknownElement
 342 (const OUString & Namespace, const OUString & Name,
 343  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 344 {
 345     if ( getContextHandler() == getDrawingShapeContext() )
 346         mpDrawing->getShapes().pushMark();
 347
 348     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 349
 350     if (xContextHandler.is())
 351         xContextHandler->startUnknownElement(Namespace, Name, Attribs);
 352 }
 353
 354 void SAL_CALL ShapeContextHandler::endFastElement(::sal_Int32 Element)
 355 {
 356     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 357
 358     if (xContextHandler.is())
 359         xContextHandler->endFastElement(Element);
 360     // In case a textbox is sent, and later we get additional properties for
 361     // the textbox, then the wps context is not cleared, so do that here.
 362     if (Element != (NMSP_wps | XML_wsp))
 363         return;
 364
 365     uno::Reference<lang::XServiceInfo> xServiceInfo(mxSavedShape, uno::UNO_QUERY);
 366     bool bTextFrame = xServiceInfo.is() && xServiceInfo->supportsService(u"com.sun.star.text.TextFrame"_ustr);
 367     bool bTextBox = false;
 368     if (!bTextFrame)
 369     {
 370         uno::Reference<beans::XPropertySet> xPropertySet(mxSavedShape, uno::UNO_QUERY);
 371         if (xPropertySet.is())
 372             xPropertySet->getPropertyValue(u"TextBox"_ustr) >>= bTextBox;
 373     }
 374     if (bTextFrame || bTextBox)
 375         mxWpsContext.clear();
 376     mxSavedShape.clear();
 377 }
 378
 379 void SAL_CALL ShapeContextHandler::endUnknownElement
 380 (const OUString & Namespace,
 381  const OUString & Name)
 382 {
 383     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 384
 385     if (xContextHandler.is())
 386         xContextHandler->endUnknownElement(Namespace, Name);
 387 }
 388
 389 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 390 ShapeContextHandler::createFastChildContext
 391 (::sal_Int32 Element,
 392  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 393 {
 394     uno::Reference< xml::sax::XFastContextHandler > xResult;
 395     uno::Reference< xml::sax::XFastContextHandler > xContextHandler(getContextHandler(Element));
 396
 397     if (xContextHandler.is())
 398         xResult.set(xContextHandler->createFastChildContext
 399                     (Element, Attribs));
 400
 401     return xResult;
 402 }
 403
 404 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 405 ShapeContextHandler::createUnknownChildContext
 406 (const OUString & Namespace,
 407  const OUString & Name,
 408  const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
 409 {
 410     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 411
 412     if (xContextHandler.is())
 413         return xContextHandler->createUnknownChildContext
 414             (Namespace, Name, Attribs);
 415
 416     return uno::Reference< xml::sax::XFastContextHandler >();
 417 }
 418
 419 void SAL_CALL ShapeContextHandler::characters(const OUString & aChars)
 420 {
 421     uno::Reference<XFastContextHandler> xContextHandler(getContextHandler());
 422
 423     if (xContextHandler.is())
 424         xContextHandler->characters(aChars);
 425 }
 426
 427 namespace // helpers for case mxWordprocessingCanvasContext
 428 {
 429     void lcl_createShapeMap(oox::drawingml::ShapePtr rShapePtr,
 430                             oox::drawingml::ShapeIdMap& rShapeMap)
 431 {
 432     std::vector< ShapePtr >& rChildren = rShapePtr->getChildren();
 433     if (rChildren.empty())
 434         return;
 435     for (auto& pIt : rChildren)
 436     {
 437         rShapeMap[pIt->getId()] = pIt; // add child itself
 438         lcl_createShapeMap(pIt, rShapeMap); // and all its descendants
 439     }
 440 }
 441
 442 } // end anonymous namespace
 443
 444 uno::Reference< drawing::XShape >
 445 ShapeContextHandler::getShape()
 446 {
 447     uno::Reference< drawing::XShape > xResult;
 448     uno::Reference< drawing::XShapes > xShapes = mxDrawPage;
 449
 450     if (mxShapeFilterBase && xShapes.is())
 451     {
 452         if ( getContextHandler() == getDrawingShapeContext() )
 453         {
 454             mpDrawing->finalizeFragmentImport();
 455             if( std::shared_ptr< vml::ShapeBase > pShape = mpDrawing->getShapes().takeLastShape() )
 456                 xResult = pShape->convertAndInsert( xShapes );
 457             // Only now remove the recursion mark, because getShape() is called in writerfilter
 458             // after endFastElement().
 459             mpDrawing->getShapes().popMark();
 460         }
 461         else if (mxDiagramShapeContext.is())
 462         {
 463             basegfx::B2DHomMatrix aMatrix;
 464             if (mpShape->getExtDrawings().empty())
 465             {
 466                 mpShape->addShape( *mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, mpShape->getFillProperties() );
 467                 xResult = mpShape->getXShape();
 468             }
 469             else
 470             {
 471                 // Prerendered diagram output is available, then use that, and throw away the original result.
 472                 for (auto const& extDrawing : mpShape->getExtDrawings())
 473                 {
 474                     OUString aFragmentPath(mxDiagramShapeContext->getFragmentPathFromRelId(extDrawing));
 475                     oox::drawingml::ShapePtr pShapePtr = std::make_shared<Shape>( "com.sun.star.drawing.GroupShape" );
 476                     pShapePtr->setDiagramType();
 477                     mxShapeFilterBase->importFragment(new ShapeDrawingFragmentHandler(*mxShapeFilterBase, aFragmentPath, pShapePtr));
 478                     pShapePtr->setDiagramDoms(mpShape->getDiagramDoms());
 479                     pShapePtr->keepDiagramDrawing(*mxShapeFilterBase, aFragmentPath);
 480
 481                     if (mpShape->getFontRefColorForNodes().isUsed())
 482                         applyFontRefColor(pShapePtr, mpShape->getFontRefColorForNodes());
 483
 484                     // migrate IDiagramHelper to new oox::Shape (from mpShape which was loaded
 485                     // to pShapePtr where the geometry is now constructed)
 486                     mpShape->migrateDiagramHelperToNewShape(pShapePtr);
 487
 488                     if (!mpShape->getChildren().empty())
 489                     {
 490                         // first child is diagram background - we want to keep it, as drawingML fallback doesn't contain it
 491                         auto& aChildren = pShapePtr->getChildren();
 492                         ShapePtr pBackground = mpShape->getChildren().front();
 493                         aChildren.insert(aChildren.begin(), pBackground);
 494                     }
 495
 496                     pShapePtr->addShape( *mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, pShapePtr->getFillProperties() );
 497                     xResult = pShapePtr->getXShape();
 498                 }
 499                 mpShape.reset();
 500             }
 501             mxDiagramShapeContext.clear();
 502         }
 503         else if (mxLockedCanvasContext.is())
 504         {
 505             ShapePtr pShape = mxLockedCanvasContext->getShape();
 506             if (pShape)
 507             {
 508                 basegfx::B2DHomMatrix aMatrix;
 509                 pShape->addShape(*mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, pShape->getFillProperties());
 510                 xResult = pShape->getXShape();
 511                 mxLockedCanvasContext.clear();
 512             }
 513         }
 514         else if (mxWordprocessingCanvasContext.is())
 515         {
 516              // group which represents the drawing canvas
 517             ShapePtr pShape = mxWordprocessingCanvasContext->getShape();
 518             if (pShape)
 519             {
 520                 basegfx::B2DHomMatrix aMatrix;
 521                 pShape->addShape(*mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, pShape->getFillProperties());
 522
 523                 // create a flat map of all shapes in the drawing canvas group.
 524                 oox::drawingml::ShapeIdMap aShapeMap;
 525                 lcl_createShapeMap(pShape, aShapeMap);
 526
 527                 // Traverse aShapeMap and generate edge related properties.
 528                 for (auto& rIt : aShapeMap)
 529                 {
 530                     if ((rIt.second)->getServiceName() == "com.sun.star.drawing.ConnectorShape")
 531                     {
 532                         ConnectorHelper::applyConnections(rIt.second, aShapeMap);
 533
 534                         if (rIt.second->getConnectorName() == u"bentConnector3"_ustr
 535                            || rIt.second->getConnectorName() == u"bentConnector4"_ustr
 536                            || rIt.second->getConnectorName() == u"bentConnector5"_ustr)
 537                         {
 538                            ConnectorHelper::applyBentHandleAdjustments(rIt.second);
 539                         }
 540                         else if (rIt.second->getConnectorName() == u"curvedConnector3"_ustr
 541                            || rIt.second->getConnectorName() == u"curvedConnector4"_ustr
 542                            || rIt.second->getConnectorName() == u"curvedConnector5"_ustr)
 543                         {
 544                             ConnectorHelper::applyCurvedHandleAdjustments(rIt.second);
 545                         }
 546                         // else use the default path of LibreOffice.
 547                         // curveConnector2 and bentConnector2 do not have handles.
 548                     }
 549                 }
 550                 xResult = pShape->getXShape();
 551                 mxWordprocessingCanvasContext.clear();
 552             }
 553         }
 554         //NMSP_dmlChart == getNamespace( mnStartToken ) check is introduced to make sure that
 555         //mnStartToken is set as NMSP_dmlChart in setStartToken.
 556         //Only in case it is set then only the below block of code for ChartShapeContext should be executed.
 557         else if (mxChartShapeContext.is() && (NMSP_dmlChart == getNamespace( getStartToken() )))
 558         {
 559             basegfx::B2DHomMatrix aMatrix;
 560             oox::drawingml::ShapePtr xShapePtr( mxChartShapeContext->getShape());
 561             // See SwXTextDocument::createInstance(), ODF import uses the same hack.
 562             xShapePtr->setServiceName(u"com.sun.star.drawing.temporaryForXMLImportOLE2Shape"_ustr);
 563             xShapePtr->addShape( *mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, xShapePtr->getFillProperties() );
 564             xResult = xShapePtr->getXShape();
 565             mxChartShapeContext.clear();
 566         }
 567         else if (mxWpsContext.is())
 568         {
 569             ShapePtr pShape = mxWpsContext->getShape();
 570             if (pShape)
 571             {
 572                 basegfx::B2DHomMatrix aMatrix;
 573                 pShape->setPosition(maPosition);
 574                 pShape->addShape(*mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, pShape->getFillProperties());
 575                 xResult = pShape->getXShape();
 576                 mxSavedShape = xResult;
 577                 mxWpsContext.clear();
 578             }
 579         }
 580         else if (mxWpgContext.is())
 581         {
 582             ShapePtr pShape = mxWpgContext->getShape();
 583             if (pShape)
 584             {
 585                 basegfx::B2DHomMatrix aMatrix;
 586                 pShape->setPosition(maPosition);
 587                 pShape->addShape(*mxShapeFilterBase, mpThemePtr.get(), xShapes, aMatrix, pShape->getFillProperties());
 588                 xResult = pShape->getXShape();
 589                 mxSavedShape = xResult;
 590                 mxWpgContext.clear();
 591             }
 592         }
 593         else if (mpShape)
 594         {
 595             basegfx::B2DHomMatrix aTransformation;
 596
 597             if (maPosition.X != 0 || maPosition.Y != 0)
 598             {
 599                 // We got a position from writerfilter/, store that in the shape, otherwise the
 600                 // position won't be set.
 601                 mpShape->setWps(true);
 602                 mpShape->setPosition(maPosition);
 603             }
 604
 605             mpShape->addShape(*mxShapeFilterBase, mpThemePtr.get(), xShapes, aTransformation, mpShape->getFillProperties() );
 606             xResult.set(mpShape->getXShape());
 607             mxGraphicShapeContext.clear( );
 608         }
 609     }
 610
 611     if (xResult)
 612         popStartToken();
 613     return xResult;
 614 }
 615
 616 void ShapeContextHandler::setDrawPage(const css::uno::Reference< css::drawing::XDrawPage > & the_value)
 617 {
 618     mxDrawPage = the_value;
 619 }
 620
 621 void ShapeContextHandler::setModel(const css::uno::Reference< css::frame::XModel > & the_value)
 622 {
 623     if( !mxShapeFilterBase.is() )
 624         throw uno::RuntimeException();
 625     uno::Reference<lang::XComponent> xComp(the_value, uno::UNO_QUERY_THROW);
 626     mxShapeFilterBase->setTargetDocument(xComp);
 627 }
 628
 629 void ShapeContextHandler::setRelationFragmentPath(const OUString & the_value)
 630 {
 631     msRelationFragmentPath = the_value;
 632 }
 633
 634 sal_Int32 ShapeContextHandler::getStartToken() const
 635 {
 636     assert(mnStartTokenStack.size() && "This stack must not be empty!");
 637     return mnStartTokenStack.top();
 638 }
 639
 640 void ShapeContextHandler::popStartToken()
 641 {
 642     if (mnStartTokenStack.size() > 1)
 643         mnStartTokenStack.pop();
 644 }
 645
 646 void ShapeContextHandler::pushStartToken( sal_Int32 _starttoken )
 647 {
 648     mnStartTokenStack.push(_starttoken);
 649 }
 650
 651 void ShapeContextHandler::setPosition(const awt::Point& rPosition)
 652 {
 653     maPosition = rPosition;
 654 }
 655
 656 void ShapeContextHandler::setSize(const awt::Size& rSize)
 657 {
 658     maSize = rSize;
 659 }
 660
 661 void ShapeContextHandler::setDocumentProperties(const uno::Reference<document::XDocumentProperties>& xDocProps)
 662 {
 663     mxDocumentProperties = xDocProps;
 664     mxShapeFilterBase->checkDocumentProperties(mxDocumentProperties);
 665 }
 666
 667 void ShapeContextHandler::setMediaDescriptor(const uno::Sequence<beans::PropertyValue>& rMediaDescriptor)
 668 {
 669     maMediaDescriptor = rMediaDescriptor;
 670 }
 671
 672 void ShapeContextHandler::setGraphicMapper(css::uno::Reference<css::graphic::XGraphicMapper> const & rxGraphicMapper)
 673 {
 674     mxShapeFilterBase->setGraphicMapper(rxGraphicMapper);
 675 }
 676
 677 void ShapeContextHandler::applyFontRefColor(const oox::drawingml::ShapePtr& pShape,
 678                                             const oox::drawingml::Color& rFontRefColor)
 679 {
 680     pShape->getShapeStyleRefs()[XML_fontRef].maPhClr = rFontRefColor;
 681     std::vector<oox::drawingml::ShapePtr>& vChildren = pShape->getChildren();
 682     for (auto const& child : vChildren)
 683     {
 684         applyFontRefColor(child, rFontRefColor);
 685     }
 686 }
 687 }
 688
 689 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */