xmloff/source/draw/shapeimport.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 <o3tl/make_unique.hxx>
  21
  22 #include <tools/debug.hxx>
  23
  24 #include <com/sun/star/text/PositionLayoutDir.hpp>
  25 #include <com/sun/star/chart/XChartDocument.hpp>
  26
  27 #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
  28 #include <osl/diagnose.h>
  29
  30 #include <list>
  31
  32 #include <xmloff/shapeimport.hxx>
  33 #include <xmloff/xmltkmap.hxx>
  34 #include <xmloff/xmlnmspe.hxx>
  35 #include <xmloff/xmltoken.hxx>
  36 #include "ximpstyl.hxx"
  37 #include "ximpshap.hxx"
  38 #include "sdpropls.hxx"
  39 #include <xmloff/xmlprmap.hxx>
  40 #include "ximp3dscene.hxx"
  41 #include "ximp3dobject.hxx"
  42 #include "ximpgrp.hxx"
  43 #include "ximplink.hxx"
  44
  45 #include <map>
  46 #include <vector>
  47
  48 using namespace ::std;
  49 using namespace ::com::sun::star;
  50 using namespace ::xmloff::token;
  51
  52 struct ConnectionHint
  53 {
  54     css::uno::Reference< css::drawing::XShape > mxConnector;
  55     bool      bStart;
  56     OUString  aDestShapeId;
  57     sal_Int32 nDestGlueId;
  58 };
  59
  60 struct XShapeCompareHelper
  61 {
  62   bool operator()(const css::uno::Reference < css::drawing::XShape >& x1,
  63                   const css::uno::Reference < css::drawing::XShape >& x2 ) const
  64   {
  65     return x1.get() < x2.get();
  66   }
  67 };
  68
  69 /** this map store all glue point id mappings for shapes that had user defined glue points. This
  70     is needed because on insertion the glue points will get a new and unique id */
  71 typedef std::map<sal_Int32,sal_Int32> GluePointIdMap;
  72 typedef std::map< css::uno::Reference < css::drawing::XShape >, GluePointIdMap, XShapeCompareHelper > ShapeGluePointsMap;
  73
  74 /** this struct is created for each startPage() call and stores information that is needed during
  75     import of shapes for one page. Since pages could be nested ( notes pages inside impress ) there
  76     is a pointer so one can build up a stack of this structs */
  77 struct XMLShapeImportPageContextImpl
  78 {
  79     ShapeGluePointsMap      maShapeGluePointsMap;
  80
  81     uno::Reference < drawing::XShapes > mxShapes;
  82
  83     std::shared_ptr<XMLShapeImportPageContextImpl> mpNext;
  84 };
  85
  86 /** this class is to enable adding members to the XMLShapeImportHelper without getting incompatible */
  87 struct XMLShapeImportHelperImpl
  88 {
  89     // context for sorting shapes
  90     std::shared_ptr<ShapeSortContext> mpSortContext;
  91
  92     std::vector<ConnectionHint> maConnections;
  93
  94     // #88546# possibility to switch progress bar handling on/off
  95     bool                        mbHandleProgressBar;
  96
  97     // stores the capability of the current model to create presentation shapes
  98     bool                        mbIsPresentationShapesSupported;
  99 };
 100
 101 XMLShapeImportHelper::XMLShapeImportHelper(
 102         SvXMLImport& rImporter,
 103         const uno::Reference< frame::XModel>& rModel,
 104         SvXMLImportPropertyMapper *pExtMapper )
 105 :   mpImpl( new XMLShapeImportHelperImpl() ),
 106
 107     mpPropertySetMapper(nullptr),
 108     mpPresPagePropsMapper(nullptr),
 109     msStartShape("StartShape"),
 110     msEndShape("EndShape"),
 111     msStartGluePointIndex("StartGluePointIndex"),
 112     msEndGluePointIndex("EndGluePointIndex"),
 113
 114     mrImporter( rImporter )
 115 {
 116     mpImpl->mpSortContext = nullptr;
 117
 118     // #88546# init to sal_False
 119     mpImpl->mbHandleProgressBar = false;
 120
 121     mpSdPropHdlFactory = new XMLSdPropHdlFactory( rModel, rImporter );
 122
 123     // construct PropertySetMapper
 124     rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper(mpSdPropHdlFactory.get(), false);
 125     mpPropertySetMapper = new SvXMLImportPropertyMapper( xMapper, rImporter );
 126
 127     if( pExtMapper )
 128     {
 129         rtl::Reference < SvXMLImportPropertyMapper > xExtMapper( pExtMapper );
 130         mpPropertySetMapper->ChainImportMapper( xExtMapper );
 131     }
 132
 133     // chain text attributes
 134     mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(rImporter));
 135     mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaDefaultExtPropMapper(rImporter));
 136
 137     // construct PresPagePropsMapper
 138     xMapper = new XMLPropertySetMapper(aXMLSDPresPageProps, mpSdPropHdlFactory.get(), false);
 139     mpPresPagePropsMapper = new SvXMLImportPropertyMapper( xMapper, rImporter );
 140
 141     uno::Reference< lang::XServiceInfo > xInfo( rImporter.GetModel(), uno::UNO_QUERY );
 142     const OUString aSName( "com.sun.star.presentation.PresentationDocument" );
 143     mpImpl->mbIsPresentationShapesSupported = xInfo.is() && xInfo->supportsService( aSName );
 144 }
 145
 146 XMLShapeImportHelper::~XMLShapeImportHelper()
 147 {
 148     SAL_WARN_IF( !mpImpl->maConnections.empty(), "xmloff", "XMLShapeImportHelper::restoreConnections() was not called!" );
 149
 150     // cleanup factory, decrease refcount. Should lead to destruction.
 151     mpSdPropHdlFactory.clear();
 152
 153     // cleanup mapper, decrease refcount. Should lead to destruction.
 154     mpPropertySetMapper.clear();
 155
 156     // cleanup presPage mapper, decrease refcount. Should lead to destruction.
 157     mpPresPagePropsMapper.clear();
 158
 159     // Styles or AutoStyles context?
 160     if(mxStylesContext.is())
 161         mxStylesContext->Clear();
 162
 163     if(mxAutoStylesContext.is())
 164         mxAutoStylesContext->Clear();
 165 }
 166
 167 const SvXMLTokenMap& XMLShapeImportHelper::GetGroupShapeElemTokenMap()
 168 {
 169     if(!mpGroupShapeElemTokenMap)
 170     {
 171         static const SvXMLTokenMapEntry aGroupShapeElemTokenMap[] =
 172         {
 173             { XML_NAMESPACE_DRAW,           XML_G,              XML_TOK_GROUP_GROUP         },
 174             { XML_NAMESPACE_DRAW,           XML_RECT,           XML_TOK_GROUP_RECT          },
 175             { XML_NAMESPACE_DRAW,           XML_LINE,           XML_TOK_GROUP_LINE          },
 176             { XML_NAMESPACE_DRAW,           XML_CIRCLE,         XML_TOK_GROUP_CIRCLE        },
 177             { XML_NAMESPACE_DRAW,           XML_ELLIPSE,        XML_TOK_GROUP_ELLIPSE       },
 178             { XML_NAMESPACE_DRAW,           XML_POLYGON,        XML_TOK_GROUP_POLYGON       },
 179             { XML_NAMESPACE_DRAW,           XML_POLYLINE,       XML_TOK_GROUP_POLYLINE      },
 180             { XML_NAMESPACE_DRAW,           XML_PATH,           XML_TOK_GROUP_PATH          },
 181
 182             { XML_NAMESPACE_DRAW,           XML_CONTROL,        XML_TOK_GROUP_CONTROL       },
 183             { XML_NAMESPACE_DRAW,           XML_CONNECTOR,      XML_TOK_GROUP_CONNECTOR     },
 184             { XML_NAMESPACE_DRAW,           XML_MEASURE,        XML_TOK_GROUP_MEASURE       },
 185             { XML_NAMESPACE_DRAW,           XML_PAGE_THUMBNAIL, XML_TOK_GROUP_PAGE          },
 186             { XML_NAMESPACE_DRAW,           XML_CAPTION,        XML_TOK_GROUP_CAPTION       },
 187
 188             { XML_NAMESPACE_CHART,          XML_CHART,          XML_TOK_GROUP_CHART         },
 189             { XML_NAMESPACE_DR3D,           XML_SCENE,          XML_TOK_GROUP_3DSCENE       },
 190
 191             { XML_NAMESPACE_DRAW,           XML_FRAME,          XML_TOK_GROUP_FRAME         },
 192             { XML_NAMESPACE_DRAW,           XML_CUSTOM_SHAPE,   XML_TOK_GROUP_CUSTOM_SHAPE  },
 193
 194             { XML_NAMESPACE_DRAW,           XML_CUSTOM_SHAPE,   XML_TOK_GROUP_CUSTOM_SHAPE  },
 195             { XML_NAMESPACE_OFFICE,         XML_ANNOTATION,     XML_TOK_GROUP_ANNOTATION    },
 196             { XML_NAMESPACE_DRAW,           XML_A,              XML_TOK_GROUP_A             },
 197
 198             XML_TOKEN_MAP_END
 199         };
 200
 201         mpGroupShapeElemTokenMap = o3tl::make_unique<SvXMLTokenMap>(aGroupShapeElemTokenMap);
 202     }
 203
 204     return *mpGroupShapeElemTokenMap;
 205 }
 206
 207 const SvXMLTokenMap& XMLShapeImportHelper::GetFrameShapeElemTokenMap()
 208 {
 209     if(!mpFrameShapeElemTokenMap)
 210     {
 211         static const SvXMLTokenMapEntry aFrameShapeElemTokenMap[] =
 212         {
 213             { XML_NAMESPACE_DRAW,           XML_TEXT_BOX,       XML_TOK_FRAME_TEXT_BOX      },
 214             { XML_NAMESPACE_DRAW,           XML_IMAGE,          XML_TOK_FRAME_IMAGE         },
 215             { XML_NAMESPACE_DRAW,           XML_OBJECT,         XML_TOK_FRAME_OBJECT        },
 216             { XML_NAMESPACE_DRAW,           XML_OBJECT_OLE,     XML_TOK_FRAME_OBJECT_OLE    },
 217             { XML_NAMESPACE_DRAW,           XML_PLUGIN,         XML_TOK_FRAME_PLUGIN        },
 218             { XML_NAMESPACE_DRAW,           XML_FLOATING_FRAME, XML_TOK_FRAME_FLOATING_FRAME},
 219             { XML_NAMESPACE_DRAW,           XML_APPLET,         XML_TOK_FRAME_APPLET        },
 220             { XML_NAMESPACE_TABLE,          XML_TABLE,          XML_TOK_FRAME_TABLE         },
 221             XML_TOKEN_MAP_END
 222         };
 223
 224         mpFrameShapeElemTokenMap = o3tl::make_unique<SvXMLTokenMap>(aFrameShapeElemTokenMap);
 225     }
 226
 227     return *mpFrameShapeElemTokenMap;
 228 }
 229
 230 const SvXMLTokenMap& XMLShapeImportHelper::Get3DSceneShapeElemTokenMap()
 231 {
 232     if(!mp3DSceneShapeElemTokenMap)
 233     {
 234         static const SvXMLTokenMapEntry a3DSceneShapeElemTokenMap[] =
 235         {
 236             { XML_NAMESPACE_DR3D,           XML_SCENE,      XML_TOK_3DSCENE_3DSCENE     },
 237             { XML_NAMESPACE_DR3D,           XML_CUBE,       XML_TOK_3DSCENE_3DCUBE      },
 238             { XML_NAMESPACE_DR3D,           XML_SPHERE,     XML_TOK_3DSCENE_3DSPHERE    },
 239             { XML_NAMESPACE_DR3D,           XML_ROTATE,     XML_TOK_3DSCENE_3DLATHE     },
 240             { XML_NAMESPACE_DR3D,           XML_EXTRUDE,    XML_TOK_3DSCENE_3DEXTRUDE   },
 241             XML_TOKEN_MAP_END
 242         };
 243
 244         mp3DSceneShapeElemTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DSceneShapeElemTokenMap);
 245     }
 246
 247     return *mp3DSceneShapeElemTokenMap;
 248 }
 249
 250 const SvXMLTokenMap& XMLShapeImportHelper::Get3DObjectAttrTokenMap()
 251 {
 252     if(!mp3DObjectAttrTokenMap)
 253     {
 254         static const SvXMLTokenMapEntry a3DObjectAttrTokenMap[] =
 255         {
 256             { XML_NAMESPACE_DRAW,           XML_STYLE_NAME,         XML_TOK_3DOBJECT_DRAWSTYLE_NAME     },
 257             { XML_NAMESPACE_DR3D,           XML_TRANSFORM,          XML_TOK_3DOBJECT_TRANSFORM          },
 258             XML_TOKEN_MAP_END
 259         };
 260
 261         mp3DObjectAttrTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DObjectAttrTokenMap);
 262     }
 263
 264     return *mp3DObjectAttrTokenMap;
 265 }
 266
 267 const SvXMLTokenMap& XMLShapeImportHelper::Get3DPolygonBasedAttrTokenMap()
 268 {
 269     if(!mp3DPolygonBasedAttrTokenMap)
 270     {
 271         static const SvXMLTokenMapEntry a3DPolygonBasedAttrTokenMap[] =
 272         {
 273             { XML_NAMESPACE_SVG,            XML_VIEWBOX,            XML_TOK_3DPOLYGONBASED_VIEWBOX      },
 274             { XML_NAMESPACE_SVG,            XML_D,                  XML_TOK_3DPOLYGONBASED_D            },
 275             XML_TOKEN_MAP_END
 276         };
 277
 278         mp3DPolygonBasedAttrTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DPolygonBasedAttrTokenMap);
 279     }
 280
 281     return *mp3DPolygonBasedAttrTokenMap;
 282 }
 283
 284 const SvXMLTokenMap& XMLShapeImportHelper::Get3DCubeObjectAttrTokenMap()
 285 {
 286     if(!mp3DCubeObjectAttrTokenMap)
 287     {
 288         static const SvXMLTokenMapEntry a3DCubeObjectAttrTokenMap[] =
 289         {
 290             { XML_NAMESPACE_DR3D,           XML_MIN_EDGE,           XML_TOK_3DCUBEOBJ_MINEDGE   },
 291             { XML_NAMESPACE_DR3D,           XML_MAX_EDGE,           XML_TOK_3DCUBEOBJ_MAXEDGE   },
 292             XML_TOKEN_MAP_END
 293         };
 294
 295         mp3DCubeObjectAttrTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DCubeObjectAttrTokenMap);
 296     }
 297
 298     return *mp3DCubeObjectAttrTokenMap;
 299 }
 300
 301 const SvXMLTokenMap& XMLShapeImportHelper::Get3DSphereObjectAttrTokenMap()
 302 {
 303     if(!mp3DSphereObjectAttrTokenMap)
 304     {
 305         static const SvXMLTokenMapEntry a3DSphereObjectAttrTokenMap[] =
 306         {
 307             { XML_NAMESPACE_DR3D,           XML_CENTER,             XML_TOK_3DSPHEREOBJ_CENTER  },
 308             { XML_NAMESPACE_DR3D,           XML_SIZE,               XML_TOK_3DSPHEREOBJ_SIZE    },
 309             XML_TOKEN_MAP_END
 310         };
 311
 312         mp3DSphereObjectAttrTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DSphereObjectAttrTokenMap);
 313     }
 314
 315     return *mp3DSphereObjectAttrTokenMap;
 316 }
 317
 318 const SvXMLTokenMap& XMLShapeImportHelper::Get3DLightAttrTokenMap()
 319 {
 320     if(!mp3DLightAttrTokenMap)
 321     {
 322         static const SvXMLTokenMapEntry a3DLightAttrTokenMap[] =
 323         {
 324             { XML_NAMESPACE_DR3D,   XML_DIFFUSE_COLOR,      XML_TOK_3DLIGHT_DIFFUSE_COLOR       },
 325             { XML_NAMESPACE_DR3D,   XML_DIRECTION,          XML_TOK_3DLIGHT_DIRECTION           },
 326             { XML_NAMESPACE_DR3D,   XML_ENABLED,            XML_TOK_3DLIGHT_ENABLED             },
 327             { XML_NAMESPACE_DR3D,   XML_SPECULAR,           XML_TOK_3DLIGHT_SPECULAR            },
 328             XML_TOKEN_MAP_END
 329         };
 330
 331         mp3DLightAttrTokenMap = o3tl::make_unique<SvXMLTokenMap>(a3DLightAttrTokenMap);
 332     }
 333
 334     return *mp3DLightAttrTokenMap;
 335 }
 336
 337 SvXMLShapeContext* XMLShapeImportHelper::Create3DSceneChildContext(
 338     SvXMLImport& rImport,
 339     sal_uInt16 p_nPrefix,
 340     const OUString& rLocalName,
 341     const uno::Reference< xml::sax::XAttributeList>& xAttrList,
 342     uno::Reference< drawing::XShapes >& rShapes)
 343 {
 344     SdXMLShapeContext *pContext = nullptr;
 345
 346     if(rShapes.is())
 347     {
 348         const SvXMLTokenMap& rTokenMap = Get3DSceneShapeElemTokenMap();
 349         switch(rTokenMap.Get(p_nPrefix, rLocalName))
 350         {
 351             case XML_TOK_3DSCENE_3DSCENE:
 352             {
 353                 // dr3d:3dscene inside dr3d:3dscene context
 354                 pContext = new SdXML3DSceneShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, false);
 355                 break;
 356             }
 357             case XML_TOK_3DSCENE_3DCUBE:
 358             {
 359                 // dr3d:3dcube inside dr3d:3dscene context
 360                 pContext = new SdXML3DCubeObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes);
 361                 break;
 362             }
 363             case XML_TOK_3DSCENE_3DSPHERE:
 364             {
 365                 // dr3d:3dsphere inside dr3d:3dscene context
 366                 pContext = new SdXML3DSphereObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes);
 367                 break;
 368             }
 369             case XML_TOK_3DSCENE_3DLATHE:
 370             {
 371                 // dr3d:3dlathe inside dr3d:3dscene context
 372                 pContext = new SdXML3DLatheObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes);
 373                 break;
 374             }
 375             case XML_TOK_3DSCENE_3DEXTRUDE:
 376             {
 377                 // dr3d:3dextrude inside dr3d:3dscene context
 378                 pContext = new SdXML3DExtrudeObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes);
 379                 break;
 380             }
 381         }
 382     }
 383
 384     if (!pContext)
 385         return nullptr;
 386
 387     // now parse the attribute list and call the child context for each unknown attribute
 388     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 389     for(sal_Int16 a(0); a < nAttrCount; a++)
 390     {
 391         const OUString& rAttrName = xAttrList->getNameByIndex(a);
 392         OUString aLocalName;
 393         sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName);
 394         const OUString aValue( xAttrList->getValueByIndex(a) );
 395
 396         pContext->processAttribute( nPrefix, aLocalName, aValue );
 397     }
 398
 399     return pContext;
 400 }
 401
 402 void XMLShapeImportHelper::SetStylesContext(SvXMLStylesContext* pNew)
 403 {
 404     mxStylesContext.set(pNew);
 405 }
 406
 407 void XMLShapeImportHelper::SetAutoStylesContext(SvXMLStylesContext* pNew)
 408 {
 409     mxAutoStylesContext.set(pNew);
 410 }
 411
 412 SvXMLShapeContext* XMLShapeImportHelper::CreateGroupChildContext(
 413     SvXMLImport& rImport,
 414     sal_uInt16 p_nPrefix,
 415     const OUString& rLocalName,
 416     const uno::Reference< xml::sax::XAttributeList>& xAttrList,
 417     uno::Reference< drawing::XShapes >& rShapes,
 418     bool bTemporaryShape)
 419 {
 420     SdXMLShapeContext *pContext = nullptr;
 421
 422     const SvXMLTokenMap& rTokenMap = GetGroupShapeElemTokenMap();
 423     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 424
 425     switch(rTokenMap.Get(p_nPrefix, rLocalName))
 426     {
 427         case XML_TOK_GROUP_GROUP:
 428         {
 429             // draw:g inside group context (RECURSIVE)
 430             pContext = new SdXMLGroupShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape);
 431             break;
 432         }
 433         case XML_TOK_GROUP_3DSCENE:
 434         {
 435             // dr3d:3dscene inside group context
 436             pContext = new SdXML3DSceneShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape);
 437             break;
 438         }
 439         case XML_TOK_GROUP_RECT:
 440         {
 441             // draw:rect inside group context
 442             pContext = new SdXMLRectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 443             break;
 444         }
 445         case XML_TOK_GROUP_LINE:
 446         {
 447             // draw:line inside group context
 448             pContext = new SdXMLLineShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 449             break;
 450         }
 451         case XML_TOK_GROUP_CIRCLE:
 452         case XML_TOK_GROUP_ELLIPSE:
 453         {
 454             // draw:circle or draw:ellipse inside group context
 455             pContext = new SdXMLEllipseShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 456             break;
 457         }
 458         case XML_TOK_GROUP_POLYGON:
 459         case XML_TOK_GROUP_POLYLINE:
 460         {
 461             // draw:polygon or draw:polyline inside group context
 462             pContext = new SdXMLPolygonShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes,
 463                 rTokenMap.Get(p_nPrefix, rLocalName) == XML_TOK_GROUP_POLYGON, bTemporaryShape );
 464             break;
 465         }
 466         case XML_TOK_GROUP_PATH:
 467         {
 468             // draw:path inside group context
 469             pContext = new SdXMLPathShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape);
 470             break;
 471         }
 472         case XML_TOK_GROUP_FRAME:
 473         {
 474             // text:text-box inside group context
 475             pContext = new SdXMLFrameShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 476             break;
 477         }
 478         case XML_TOK_GROUP_CONTROL:
 479         {
 480             // draw:control inside group context
 481             pContext = new SdXMLControlShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 482             break;
 483         }
 484         case XML_TOK_GROUP_CONNECTOR:
 485         {
 486             // draw:connector inside group context
 487             pContext = new SdXMLConnectorShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 488             break;
 489         }
 490         case XML_TOK_GROUP_MEASURE:
 491         {
 492             // draw:measure inside group context
 493             pContext = new SdXMLMeasureShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 494             break;
 495         }
 496         case XML_TOK_GROUP_PAGE:
 497         {
 498             // draw:page inside group context
 499             pContext = new SdXMLPageShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 500             break;
 501         }
 502         case XML_TOK_GROUP_CAPTION:
 503         case XML_TOK_GROUP_ANNOTATION:
 504         {
 505             // draw:caption inside group context
 506             pContext = new SdXMLCaptionShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 507             break;
 508         }
 509         case XML_TOK_GROUP_CHART:
 510         {
 511             // chart:chart inside group context
 512             pContext = new SdXMLChartShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape );
 513             break;
 514         }
 515         case XML_TOK_GROUP_CUSTOM_SHAPE:
 516         {
 517             // draw:customshape
 518             pContext = new SdXMLCustomShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 519             break;
 520         }
 521          case XML_TOK_GROUP_A:
 522          {
 523              return new SdXMLShapeLinkContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 524          }
 525         // add other shapes here...
 526         default:
 527             return new SvXMLShapeContext( rImport, p_nPrefix, rLocalName, bTemporaryShape );
 528     }
 529
 530     // now parse the attribute list and call the child context for each unknown attribute
 531     for(sal_Int16 a(0); a < nAttrCount; a++)
 532     {
 533         const OUString& rAttrName = xAttrList->getNameByIndex(a);
 534         OUString aLocalName;
 535         sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName);
 536         const OUString aValue( xAttrList->getValueByIndex(a) );
 537
 538         pContext->processAttribute( nPrefix, aLocalName, aValue );
 539     }
 540
 541     return pContext;
 542 }
 543
 544 // This method is called from SdXMLFrameShapeContext to create children of draw:frame
 545 SvXMLShapeContext* XMLShapeImportHelper::CreateFrameChildContext(
 546     SvXMLImport& rImport,
 547     sal_uInt16 p_nPrefix,
 548     const OUString& rLocalName,
 549     const uno::Reference< xml::sax::XAttributeList>& rAttrList,
 550     uno::Reference< drawing::XShapes >& rShapes,
 551     const uno::Reference< xml::sax::XAttributeList>& rFrameAttrList)
 552 {
 553     SdXMLShapeContext *pContext = nullptr;
 554
 555     const SvXMLTokenMap& rTokenMap = GetFrameShapeElemTokenMap();
 556
 557     SvXMLAttributeList *pAttrList = new SvXMLAttributeList( rAttrList );
 558     if( rFrameAttrList.is() )
 559         pAttrList->AppendAttributeList( rFrameAttrList );
 560     uno::Reference < xml::sax::XAttributeList > xAttrList = pAttrList;
 561
 562     switch(rTokenMap.Get(p_nPrefix, rLocalName))
 563     {
 564         case XML_TOK_FRAME_TEXT_BOX:
 565         {
 566             // text:text-box inside group context
 567             pContext = new SdXMLTextBoxShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 568             break;
 569         }
 570         case XML_TOK_FRAME_IMAGE:
 571         {
 572             // office:image inside group context
 573             pContext = new SdXMLGraphicObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 574             break;
 575         }
 576         case XML_TOK_FRAME_OBJECT:
 577         case XML_TOK_FRAME_OBJECT_OLE:
 578         {
 579             // draw:object or draw:object_ole
 580             pContext = new SdXMLObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 581             break;
 582         }
 583         case XML_TOK_FRAME_TABLE:
 584         {
 585             // draw:object or draw:object_ole
 586             if( rImport.IsTableShapeSupported() )
 587                 pContext = new SdXMLTableShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 588             break;
 589
 590         }
 591         case XML_TOK_FRAME_PLUGIN:
 592         {
 593             // draw:plugin
 594             pContext = new SdXMLPluginShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 595             break;
 596         }
 597         case XML_TOK_FRAME_FLOATING_FRAME:
 598         {
 599             // draw:floating-frame
 600             pContext = new SdXMLFloatingFrameShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 601             break;
 602         }
 603         case XML_TOK_FRAME_APPLET:
 604         {
 605             // draw:applet
 606             pContext = new SdXMLAppletShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes );
 607             break;
 608         }
 609         // add other shapes here...
 610         default:
 611             break;
 612     }
 613
 614     if( pContext )
 615     {
 616         // now parse the attribute list and call the child context for each unknown attribute
 617         sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 618         for(sal_Int16 a(0); a < nAttrCount; a++)
 619         {
 620             const OUString& rAttrName = xAttrList->getNameByIndex(a);
 621             OUString aLocalName;
 622             sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName);
 623             const OUString aValue( xAttrList->getValueByIndex(a) );
 624
 625             pContext->processAttribute( nPrefix, aLocalName, aValue );
 626         }
 627     }
 628
 629     return pContext;
 630 }
 631
 632 SvXMLImportContext *XMLShapeImportHelper::CreateFrameChildContext(
 633     SvXMLImportContext *pThisContext,
 634     sal_uInt16 nPrefix,
 635     const OUString& rLocalName,
 636     const uno::Reference< xml::sax::XAttributeList>& xAttrList )
 637 {
 638     SvXMLImportContext * pContext = nullptr;
 639
 640     SdXMLFrameShapeContext *pFrameContext = dynamic_cast<SdXMLFrameShapeContext*>( pThisContext  );
 641     if( pFrameContext )
 642         pContext = pFrameContext->CreateChildContext( nPrefix, rLocalName, xAttrList );
 643
 644     return pContext;
 645 }
 646
 647 /** this function is called whenever the implementation classes like to add this new
 648     shape to the given XShapes.
 649 */
 650 void XMLShapeImportHelper::addShape( uno::Reference< drawing::XShape >& rShape,
 651                                      const uno::Reference< xml::sax::XAttributeList >&,
 652                                      uno::Reference< drawing::XShapes >& rShapes)
 653 {
 654     if( rShape.is() && rShapes.is() )
 655     {
 656         // add new shape to parent
 657         rShapes->add( rShape );
 658     }
 659 }
 660
 661 /** this function is called whenever the implementation classes have finished importing
 662     a shape to the given XShapes. The shape is already inserted into its XShapes and
 663     all properties and styles are set.
 664 */
 665 void XMLShapeImportHelper::finishShape(
 666         css::uno::Reference< css::drawing::XShape >& rShape,
 667         const css::uno::Reference< css::xml::sax::XAttributeList >&,
 668         css::uno::Reference< css::drawing::XShapes >&)
 669 {
 670     /* Set property <PositionLayoutDir>
 671        to <PositionInHoriL2R>, if it exists and the import states that
 672        the shape positioning attributes are in horizontal left-to-right
 673        layout. This is the case for the OpenOffice.org file format.
 674        This setting is done for Writer documents, because the property
 675        only exists at service css::text::Shape - the Writer
 676        UNO service for shapes.
 677        The value indicates that the positioning attributes are given
 678        in horizontal left-to-right layout. The property is evaluated
 679        during the first positioning of the shape in order to convert
 680        the shape position given in the OpenOffice.org file format to
 681        the one for the OASIS Open Office file format. (#i28749#, #i36248#)
 682     */
 683     uno::Reference< beans::XPropertySet > xPropSet(rShape, uno::UNO_QUERY);
 684     if ( xPropSet.is() )
 685     {
 686         if ( mrImporter.IsShapePositionInHoriL2R() &&
 687              xPropSet->getPropertySetInfo()->hasPropertyByName(
 688                 "PositionLayoutDir") )
 689         {
 690             uno::Any aPosLayoutDir;
 691             aPosLayoutDir <<= text::PositionLayoutDir::PositionInHoriL2R;
 692             xPropSet->setPropertyValue( "PositionLayoutDir", aPosLayoutDir );
 693         }
 694     }
 695 }
 696
 697 // helper functions for z-order sorting
 698 struct ZOrderHint
 699 {
 700     sal_Int32 nIs;
 701     sal_Int32 nShould;
 702     /// The hint is for this shape.
 703     uno::Reference<drawing::XShape> xShape;
 704
 705     bool operator<(const ZOrderHint& rComp) const { return nShould < rComp.nShould; }
 706 };
 707
 708 class ShapeSortContext
 709 {
 710 public:
 711     uno::Reference< drawing::XShapes > mxShapes;
 712     vector<ZOrderHint>              maZOrderList;
 713     vector<ZOrderHint>              maUnsortedList;
 714
 715     sal_Int32                       mnCurrentZ;
 716     std::shared_ptr<ShapeSortContext> mpParentContext;
 717
 718     ShapeSortContext( uno::Reference< drawing::XShapes >& rShapes, std::shared_ptr<ShapeSortContext> pParentContext );
 719
 720     void popGroupAndSort();
 721 private:
 722     void moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos );
 723 };
 724
 725 ShapeSortContext::ShapeSortContext( uno::Reference< drawing::XShapes >& rShapes, std::shared_ptr<ShapeSortContext> pParentContext )
 726 :   mxShapes( rShapes ), mnCurrentZ( 0 ), mpParentContext( pParentContext )
 727 {
 728 }
 729
 730 void ShapeSortContext::moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos )
 731 {
 732     uno::Any aAny( mxShapes->getByIndex( nSourcePos ) );
 733     uno::Reference< beans::XPropertySet > xPropSet;
 734     aAny >>= xPropSet;
 735
 736     if( xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName( "ZOrder" ) )
 737     {
 738         xPropSet->setPropertyValue( "ZOrder", uno::Any(nDestPos) );
 739
 740         for( ZOrderHint& rHint : maZOrderList )
 741         {
 742             if( rHint.nIs < nSourcePos )
 743             {
 744                 DBG_ASSERT(rHint.nIs >= nDestPos, "Shape sorting failed" );
 745                 rHint.nIs++;
 746             }
 747         }
 748
 749         for( ZOrderHint& rHint : maUnsortedList )
 750         {
 751             if( rHint.nIs < nSourcePos )
 752             {
 753                 SAL_WARN_IF( rHint.nIs < nDestPos, "xmloff", "shape sorting failed" );
 754                 rHint.nIs++;
 755             }
 756         }
 757     }
 758 }
 759
 760 // sort shapes
 761 void ShapeSortContext::popGroupAndSort()
 762 {
 763     // only do something if we have shapes to sort
 764     if( maZOrderList.empty() )
 765         return;
 766
 767     // check if there are more shapes than inserted with ::shapeWithZIndexAdded()
 768     // This can happen if there where already shapes on the page before import
 769     // Since the writer may delete some of this shapes during import, we need
 770     // to do this here and not in our c'tor anymore
 771
 772     // check if we have more shapes than we know of
 773     sal_Int32 nCount = mxShapes->getCount();
 774
 775     nCount -= maZOrderList.size();
 776     nCount -= maUnsortedList.size();
 777
 778     if( nCount > 0 )
 779     {
 780         // first update offsets of added shapes
 781         for (ZOrderHint& rHint : maZOrderList)
 782             rHint.nIs += nCount;
 783         for (ZOrderHint& rHint : maUnsortedList)
 784             rHint.nIs += nCount;
 785
 786         // second add the already existing shapes in the unsorted list
 787         ZOrderHint aNewHint;
 788         do
 789         {
 790             nCount--;
 791
 792             aNewHint.nIs = nCount;
 793             aNewHint.nShould = -1;
 794
 795             maUnsortedList.insert(maUnsortedList.begin(), aNewHint);
 796         }
 797         while( nCount );
 798     }
 799
 800     // sort z-ordered shapes by nShould field
 801     std::sort(maZOrderList.begin(), maZOrderList.end());
 802
 803     // this is the current index, all shapes before that
 804     // index are finished
 805     sal_Int32 nIndex = 0;
 806     for (ZOrderHint& rHint : maZOrderList)
 807     {
 808         for (vector<ZOrderHint>::iterator aIt = maUnsortedList.begin(); aIt != maUnsortedList.end() && nIndex < rHint.nShould; )
 809         {
 810             moveShape( (*aIt).nIs, nIndex++ );
 811             aIt = maUnsortedList.erase(aIt);
 812
 813         }
 814
 815         if(rHint.nIs != nIndex )
 816             moveShape( rHint.nIs, nIndex );
 817
 818         nIndex++;
 819     }
 820     maZOrderList.clear();
 821 }
 822
 823 void XMLShapeImportHelper::pushGroupForSorting( uno::Reference< drawing::XShapes >& rShapes )
 824 {
 825     mpImpl->mpSortContext = std::make_shared<ShapeSortContext>( rShapes, mpImpl->mpSortContext );
 826 }
 827
 828 void XMLShapeImportHelper::popGroupAndSort()
 829 {
 830     SAL_WARN_IF( !mpImpl->mpSortContext, "xmloff", "No context to sort!" );
 831     if( !mpImpl->mpSortContext )
 832         return;
 833
 834     try
 835     {
 836         mpImpl->mpSortContext->popGroupAndSort();
 837     }
 838     catch( const uno::Exception& rException )
 839     {
 840         SAL_WARN("xmloff", "exception while sorting shapes, sorting failed: " << rException.Message);
 841     }
 842
 843     // put parent on top and drop current context, we are done
 844     mpImpl->mpSortContext = mpImpl->mpSortContext->mpParentContext;
 845 }
 846
 847 void XMLShapeImportHelper::shapeWithZIndexAdded( css::uno::Reference< css::drawing::XShape >& xShape, sal_Int32 nZIndex )
 848 {
 849     if( mpImpl->mpSortContext)
 850     {
 851         ZOrderHint aNewHint;
 852         aNewHint.nIs = mpImpl->mpSortContext->mnCurrentZ++;
 853         aNewHint.nShould = nZIndex;
 854         aNewHint.xShape = xShape;
 855
 856         if( nZIndex == -1 )
 857         {
 858             // don't care, so add to unsorted list
 859             mpImpl->mpSortContext->maUnsortedList.push_back(aNewHint);
 860         }
 861         else
 862         {
 863             // insert into sort list
 864             mpImpl->mpSortContext->maZOrderList.push_back(aNewHint);
 865         }
 866     }
 867 }
 868
 869 void XMLShapeImportHelper::shapeRemoved(const uno::Reference<drawing::XShape>& xShape)
 870 {
 871     auto it = std::find_if(mpImpl->mpSortContext->maZOrderList.begin(), mpImpl->mpSortContext->maZOrderList.end(), [&xShape](const ZOrderHint& rHint)
 872     {
 873         return rHint.xShape == xShape;
 874     });
 875     if (it == mpImpl->mpSortContext->maZOrderList.end())
 876         // Part of the unsorted list, nothing to do.
 877         return;
 878
 879     sal_Int32 nZIndex = it->nIs;
 880
 881     for (it = mpImpl->mpSortContext->maZOrderList.begin(); it != mpImpl->mpSortContext->maZOrderList.end();)
 882     {
 883         if (it->nIs == nZIndex)
 884         {
 885             // This is xShape: remove it and adjust the max of indexes
 886             // accordingly.
 887             it = mpImpl->mpSortContext->maZOrderList.erase(it);
 888             mpImpl->mpSortContext->mnCurrentZ--;
 889             continue;
 890         }
 891         else if (it->nIs > nZIndex)
 892             // On top of xShape: adjust actual index to reflect removal.
 893             it->nIs--;
 894
 895         // On top of or below xShape.
 896         ++it;
 897     }
 898 }
 899
 900 void XMLShapeImportHelper::addShapeConnection( css::uno::Reference< css::drawing::XShape >& rConnectorShape,
 901                          bool bStart,
 902                          const OUString& rDestShapeId,
 903                          sal_Int32 nDestGlueId )
 904 {
 905     ConnectionHint aHint;
 906     aHint.mxConnector = rConnectorShape;
 907     aHint.bStart = bStart;
 908     aHint.aDestShapeId = rDestShapeId;
 909     aHint.nDestGlueId = nDestGlueId;
 910
 911     mpImpl->maConnections.push_back( aHint );
 912 }
 913
 914 void XMLShapeImportHelper::restoreConnections()
 915 {
 916     if( !mpImpl->maConnections.empty() )
 917     {
 918         const vector<ConnectionHint>::size_type nCount = mpImpl->maConnections.size();
 919         for( vector<ConnectionHint>::size_type i = 0; i < nCount; i++ )
 920         {
 921             ConnectionHint& rHint = mpImpl->maConnections[i];
 922             uno::Reference< beans::XPropertySet > xConnector( rHint.mxConnector, uno::UNO_QUERY );
 923             if( xConnector.is() )
 924             {
 925                 // #86637# remember line deltas
 926                 uno::Any aLine1Delta;
 927                 uno::Any aLine2Delta;
 928                 uno::Any aLine3Delta;
 929                 OUString aStr1("EdgeLine1Delta");
 930                 OUString aStr2("EdgeLine2Delta");
 931                 OUString aStr3("EdgeLine3Delta");
 932                 aLine1Delta = xConnector->getPropertyValue(aStr1);
 933                 aLine2Delta = xConnector->getPropertyValue(aStr2);
 934                 aLine3Delta = xConnector->getPropertyValue(aStr3);
 935
 936                 // #86637# simply setting these values WILL force the connector to do
 937                 // an new layout promptly. So the line delta values have to be rescued
 938                 // and restored around connector changes.
 939                 uno::Reference< drawing::XShape > xShape(
 940                     mrImporter.getInterfaceToIdentifierMapper().getReference( rHint.aDestShapeId ), uno::UNO_QUERY );
 941                 if( xShape.is() )
 942                 {
 943                     xConnector->setPropertyValue( rHint.bStart ? msStartShape : msEndShape, uno::Any(xShape) );
 944
 945                     sal_Int32 nGlueId = rHint.nDestGlueId < 4 ? rHint.nDestGlueId : getGluePointId( xShape, rHint.nDestGlueId );
 946                     xConnector->setPropertyValue( rHint.bStart ? msStartGluePointIndex : msEndGluePointIndex, uno::Any(nGlueId) );
 947                 }
 948
 949                 // #86637# restore line deltas
 950                 xConnector->setPropertyValue(aStr1, aLine1Delta );
 951                 xConnector->setPropertyValue(aStr2, aLine2Delta );
 952                 xConnector->setPropertyValue(aStr3, aLine3Delta );
 953             }
 954         }
 955         mpImpl->maConnections.clear();
 956     }
 957 }
 958
 959 SvXMLImportPropertyMapper* XMLShapeImportHelper::CreateShapePropMapper( const uno::Reference< frame::XModel>& rModel, SvXMLImport& rImport )
 960 {
 961     rtl::Reference< XMLPropertyHandlerFactory > xFactory = new XMLSdPropHdlFactory( rModel, rImport );
 962     rtl::Reference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( xFactory, false );
 963     SvXMLImportPropertyMapper* pResult = new SvXMLImportPropertyMapper( xMapper, rImport );
 964
 965     // chain text attributes
 966     pResult->ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper( rImport ) );
 967     return pResult;
 968 }
 969
 970 /** adds a mapping for a glue point identifier from an xml file to the identifier created after inserting
 971     the new glue point into the core. The saved mappings can be retrieved by getGluePointId() */
 972 void XMLShapeImportHelper::addGluePointMapping( css::uno::Reference< css::drawing::XShape >& xShape,
 973                           sal_Int32 nSourceId, sal_Int32 nDestinnationId )
 974 {
 975     if( mpPageContext )
 976         mpPageContext->maShapeGluePointsMap[xShape][nSourceId] = nDestinnationId;
 977 }
 978
 979 /** find mapping for given DestinationID. This allows to extract the original draw:id imported with a draw:glue-point */
 980 sal_Int32 XMLShapeImportHelper::findGluePointMapping(
 981     const css::uno::Reference< css::drawing::XShape >& xShape,
 982     sal_Int32 nDestinnationId ) const
 983 {
 984     if( mpPageContext )
 985     {
 986         ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) );
 987
 988         if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() )
 989         {
 990             GluePointIdMap::iterator aShapeIdIter = (*aShapeIter).second.begin();
 991             GluePointIdMap::iterator aShapeIdEnd  = (*aShapeIter).second.end();
 992
 993             while ( aShapeIdIter != aShapeIdEnd )
 994             {
 995                 if ( (*aShapeIdIter).second == nDestinnationId )
 996                 {
 997                     return (*aShapeIdIter).first;
 998                 }
 999
1000                 ++aShapeIdIter;
1001             }
1002         }
1003     }
1004
1005     return -1;
1006 }
1007
1008 /** moves all current DestinationId's by n */
1009 void XMLShapeImportHelper::moveGluePointMapping( const css::uno::Reference< css::drawing::XShape >& xShape, const sal_Int32 n )
1010 {
1011     if( mpPageContext )
1012     {
1013         ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) );
1014         if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() )
1015         {
1016             GluePointIdMap::iterator aShapeIdIter = (*aShapeIter).second.begin();
1017             GluePointIdMap::iterator aShapeIdEnd  = (*aShapeIter).second.end();
1018             while ( aShapeIdIter != aShapeIdEnd )
1019             {
1020                 if ( (*aShapeIdIter).second != -1 )
1021                     (*aShapeIdIter).second += n;
1022                 ++aShapeIdIter;
1023             }
1024         }
1025     }
1026 }
1027
1028 /** retrieves a mapping for a glue point identifier from the current xml file to the identifier created after
1029     inserting the new glue point into the core. The mapping must be initialized first with addGluePointMapping() */
1030 sal_Int32 XMLShapeImportHelper::getGluePointId( const css::uno::Reference< css::drawing::XShape >& xShape, sal_Int32 nSourceId )
1031 {
1032     if( mpPageContext )
1033     {
1034         ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) );
1035         if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() )
1036         {
1037             GluePointIdMap::iterator aIdIter = (*aShapeIter).second.find(nSourceId);
1038             if( aIdIter != (*aShapeIter).second.end() )
1039                 return (*aIdIter).second;
1040         }
1041     }
1042
1043     return -1;
1044 }
1045
1046 /** this method must be calling before the first shape is imported for the given page */
1047 void XMLShapeImportHelper::startPage( css::uno::Reference< css::drawing::XShapes >& rShapes )
1048 {
1049     const std::shared_ptr<XMLShapeImportPageContextImpl> pOldContext = mpPageContext;
1050     mpPageContext = std::make_shared<XMLShapeImportPageContextImpl>();
1051     mpPageContext->mpNext = pOldContext;
1052     mpPageContext->mxShapes = rShapes;
1053 }
1054
1055 /** this method must be calling after the last shape is imported for the given page */
1056 void XMLShapeImportHelper::endPage( css::uno::Reference< css::drawing::XShapes >& rShapes )
1057 {
1058     SAL_WARN_IF( !mpPageContext || (mpPageContext->mxShapes != rShapes), "xmloff", "wrong call to endPage(), no startPage called or wrong page" );
1059     if( nullptr == mpPageContext )
1060         return;
1061
1062     restoreConnections();
1063
1064     mpPageContext = mpPageContext->mpNext;
1065 }
1066
1067 /** defines if the import should increment the progress bar or not */
1068 void XMLShapeImportHelper::enableHandleProgressBar()
1069 {
1070     mpImpl->mbHandleProgressBar = true;
1071 }
1072
1073 bool XMLShapeImportHelper::IsHandleProgressBarEnabled() const
1074 {
1075     return mpImpl->mbHandleProgressBar;
1076 }
1077
1078 /** queries the capability of the current model to create presentation shapes */
1079 bool XMLShapeImportHelper::IsPresentationShapesSupported()
1080 {
1081     return mpImpl->mbIsPresentationShapesSupported;
1082 }
1083
1084 const rtl::Reference< XMLTableImport >& XMLShapeImportHelper::GetShapeTableImport()
1085 {
1086     if( !mxShapeTableImport.is() )
1087     {
1088         rtl::Reference< XMLPropertyHandlerFactory > xFactory( new XMLSdPropHdlFactory( mrImporter.GetModel(), mrImporter ) );
1089         rtl::Reference< XMLPropertySetMapper > xPropertySetMapper( new XMLShapePropertySetMapper( xFactory.get(), false ) );
1090         mxShapeTableImport = new XMLTableImport( mrImporter, xPropertySetMapper, xFactory );
1091     }
1092
1093     return mxShapeTableImport;
1094 }
1095
1096 void SvXMLShapeContext::setHyperlink( const OUString& rHyperlink )
1097 {
1098     msHyperlink = rHyperlink;
1099 }
1100
1101 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */