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