/************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2008 by Sun Microsystems, Inc. * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: shapeimport.cxx,v $ * $Revision: 1.68 $ * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_xmloff.hxx" #include #include #include #include "unointerfacetouniqueidentifiermapper.hxx" #include #ifndef _XMLOFF_SHAPEIMPORT_HXX #include #endif #include #include "xmlnmspe.hxx" #include #include "ximpstyl.hxx" #include "ximpshap.hxx" #include "sdpropls.hxx" #include #include "ximp3dscene.hxx" #include "ximp3dobject.hxx" #include "ximpgrp.hxx" #include "ximplink.hxx" #include #include using ::rtl::OUString; using ::rtl::OUStringBuffer; using namespace ::std; using namespace ::com::sun::star; using namespace ::xmloff::token; ////////////////////////////////////////////////////////////////////////////// struct ltint32 { bool operator()(const sal_Int32 p, sal_Int32 q) const { return p < q; } }; typedef std::map,ltint32> IdShapeMap; struct ConnectionHint { com::sun::star::uno::Reference< com::sun::star::drawing::XShape > mxConnector; sal_Bool bStart; OUString aDestShapeId; sal_Int32 nDestGlueId; }; struct XShapeCompareHelper { bool operator()(com::sun::star::uno::Reference < com::sun::star::drawing::XShape > x1, com::sun::star::uno::Reference < com::sun::star::drawing::XShape > x2 ) const { return x1.get() < x2.get(); } }; /** this map store all glue point id mappings for shapes that had user defined glue points. This is needed because on insertion the glue points will get a new and unique id */ typedef std::map GluePointIdMap; typedef std::map< com::sun::star::uno::Reference < com::sun::star::drawing::XShape >, GluePointIdMap, XShapeCompareHelper > ShapeGluePointsMap; /** this struct is created for each startPage() call and stores information that is needed during import of shapes for one page. Since pages could be nested ( notes pages inside impress ) there is a pointer so one can build up a stack of this structs */ struct XMLShapeImportPageContextImpl { ShapeGluePointsMap maShapeGluePointsMap; uno::Reference < drawing::XShapes > mxShapes; struct XMLShapeImportPageContextImpl* mpNext; }; /** this class is to enable adding members to the XMLShapeImportHelper without getting incompatible */ struct XMLShapeImportHelperImpl { // context for sorting shapes ShapeSortContext* mpSortContext; IdShapeMap maShapeIds; std::vector maConnections; // #88546# possibility to swich progress bar handling on/off sal_Bool mbHandleProgressBar; // stores the capability of the current model to create presentation shapes sal_Bool mbIsPresentationShapesSupported; }; ////////////////////////////////////////////////////////////////////////////// XMLShapeImportHelper::XMLShapeImportHelper( SvXMLImport& rImporter, const uno::Reference< frame::XModel>& rModel, SvXMLImportPropertyMapper *pExtMapper ) : mpPageContext(NULL), mxModel(rModel), mpPropertySetMapper(0L), mpPresPagePropsMapper(0L), mpStylesContext(0L), mpAutoStylesContext(0L), mpGroupShapeElemTokenMap(0L), mpFrameShapeElemTokenMap(0L), mp3DSceneShapeElemTokenMap(0L), mp3DObjectAttrTokenMap(0L), mp3DPolygonBasedAttrTokenMap(0L), mp3DCubeObjectAttrTokenMap(0L), mp3DSphereObjectAttrTokenMap(0L), mp3DSceneShapeAttrTokenMap(0L), mp3DLightAttrTokenMap(0L), mpPathShapeAttrTokenMap(0L), mpPolygonShapeAttrTokenMap(0L), msStartShape(RTL_CONSTASCII_USTRINGPARAM("StartShape")), msEndShape(RTL_CONSTASCII_USTRINGPARAM("EndShape")), msStartGluePointIndex(RTL_CONSTASCII_USTRINGPARAM("StartGluePointIndex")), msEndGluePointIndex(RTL_CONSTASCII_USTRINGPARAM("EndGluePointIndex")), mrImporter( rImporter ) { mpImpl = new XMLShapeImportHelperImpl(); mpImpl->mpSortContext = 0; // #88546# init to FALSE mpImpl->mbHandleProgressBar = sal_False; mpSdPropHdlFactory = new XMLSdPropHdlFactory( rModel, rImporter ); // set lock to avoid deletion mpSdPropHdlFactory->acquire(); // construct PropertySetMapper UniReference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper(mpSdPropHdlFactory); mpPropertySetMapper = new SvXMLImportPropertyMapper( xMapper, rImporter ); // set lock to avoid deletion mpPropertySetMapper->acquire(); if( pExtMapper ) { UniReference < SvXMLImportPropertyMapper > xExtMapper( pExtMapper ); mpPropertySetMapper->ChainImportMapper( xExtMapper ); } // chain text attributes mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(rImporter)); mpPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaDefaultExtPropMapper(rImporter)); /* // chain form attributes const UniReference< SvXMLImportPropertyMapper> xFormMapper( rImporter.GetFormImport()->getStylePropertyMapper().getBodyPtr() ); mpPropertySetMapper->ChainImportMapper(xFormMapper); */ // construct PresPagePropsMapper xMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLSDPresPageProps, mpSdPropHdlFactory); mpPresPagePropsMapper = new SvXMLImportPropertyMapper( xMapper, rImporter ); if(mpPresPagePropsMapper) { // set lock to avoid deletion mpPresPagePropsMapper->acquire(); } uno::Reference< lang::XServiceInfo > xInfo( rImporter.GetModel(), uno::UNO_QUERY ); const OUString aSName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.PresentationDocument") ); mpImpl->mbIsPresentationShapesSupported = xInfo.is() && xInfo->supportsService( aSName ); } ////////////////////////////////////////////////////////////////////////////// XMLShapeImportHelper::~XMLShapeImportHelper() { DBG_ASSERT( mpImpl->maConnections.empty(), "XMLShapeImportHelper::restoreConnections() was not called!" ); // cleanup factory, decrease refcount. Should lead to destruction. if(mpSdPropHdlFactory) { mpSdPropHdlFactory->release(); mpSdPropHdlFactory = 0L; } // cleanup mapper, decrease refcount. Should lead to destruction. if(mpPropertySetMapper) { mpPropertySetMapper->release(); mpPropertySetMapper = 0L; } // cleanup presPage mapper, decrease refcount. Should lead to destruction. if(mpPresPagePropsMapper) { mpPresPagePropsMapper->release(); mpPresPagePropsMapper = 0L; } if(mpGroupShapeElemTokenMap) delete mpGroupShapeElemTokenMap; if(mpFrameShapeElemTokenMap) delete mpFrameShapeElemTokenMap; /* if(mpShapeAttrTokenMap) delete mpShapeAttrTokenMap; if(mpRectShapeAttrTokenMap) delete mpRectShapeAttrTokenMap; if(mpLineShapeAttrTokenMap) delete mpLineShapeAttrTokenMap; if(mpEllipseShapeAttrTokenMap) delete mpEllipseShapeAttrTokenMap; if(mpTextBoxShapeAttrTokenMap) delete mpTextBoxShapeAttrTokenMap; if(mpControlShapeAttrTokenMap) delete mpControlShapeAttrTokenMap; if(mpPageShapeAttrTokenMap) delete mpPageShapeAttrTokenMap; if(mpGraphicObjectShapeAttrTokenMap) delete mpGraphicObjectShapeAttrTokenMap; */ if(mpPolygonShapeAttrTokenMap) delete mpPolygonShapeAttrTokenMap; if(mpPathShapeAttrTokenMap) delete mpPathShapeAttrTokenMap; if(mp3DSceneShapeElemTokenMap) delete mp3DSceneShapeElemTokenMap; if(mp3DObjectAttrTokenMap) delete mp3DObjectAttrTokenMap; if(mp3DPolygonBasedAttrTokenMap) delete mp3DPolygonBasedAttrTokenMap; if(mp3DCubeObjectAttrTokenMap) delete mp3DCubeObjectAttrTokenMap; if(mp3DSphereObjectAttrTokenMap) delete mp3DSphereObjectAttrTokenMap; if(mp3DSceneShapeAttrTokenMap) delete mp3DSceneShapeAttrTokenMap; if(mp3DLightAttrTokenMap) delete mp3DLightAttrTokenMap; // Styles or AutoStyles context? if(mpStylesContext) { mpStylesContext->Clear(); mpStylesContext->ReleaseRef(); } if(mpAutoStylesContext) { mpAutoStylesContext->Clear(); mpAutoStylesContext->ReleaseRef(); } delete mpImpl; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetGroupShapeElemTokenMap() { if(!mpGroupShapeElemTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aGroupShapeElemTokenMap[] = { { XML_NAMESPACE_DRAW, XML_G, XML_TOK_GROUP_GROUP }, { XML_NAMESPACE_DRAW, XML_RECT, XML_TOK_GROUP_RECT }, { XML_NAMESPACE_DRAW, XML_LINE, XML_TOK_GROUP_LINE }, { XML_NAMESPACE_DRAW, XML_CIRCLE, XML_TOK_GROUP_CIRCLE }, { XML_NAMESPACE_DRAW, XML_ELLIPSE, XML_TOK_GROUP_ELLIPSE }, { XML_NAMESPACE_DRAW, XML_POLYGON, XML_TOK_GROUP_POLYGON }, { XML_NAMESPACE_DRAW, XML_POLYLINE, XML_TOK_GROUP_POLYLINE }, { XML_NAMESPACE_DRAW, XML_PATH, XML_TOK_GROUP_PATH }, { XML_NAMESPACE_DRAW, XML_CONTROL, XML_TOK_GROUP_CONTROL }, { XML_NAMESPACE_DRAW, XML_CONNECTOR, XML_TOK_GROUP_CONNECTOR }, { XML_NAMESPACE_DRAW, XML_MEASURE, XML_TOK_GROUP_MEASURE }, { XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, XML_TOK_GROUP_PAGE }, { XML_NAMESPACE_DRAW, XML_CAPTION, XML_TOK_GROUP_CAPTION }, { XML_NAMESPACE_CHART, XML_CHART, XML_TOK_GROUP_CHART }, { XML_NAMESPACE_DR3D, XML_SCENE, XML_TOK_GROUP_3DSCENE }, { XML_NAMESPACE_DRAW, XML_FRAME, XML_TOK_GROUP_FRAME }, { XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, XML_TOK_GROUP_CUSTOM_SHAPE }, { XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, XML_TOK_GROUP_CUSTOM_SHAPE }, { XML_NAMESPACE_OFFICE, XML_ANNOTATION, XML_TOK_GROUP_ANNOTATION }, { XML_NAMESPACE_DRAW, XML_A, XML_TOK_GROUP_A }, XML_TOKEN_MAP_END }; mpGroupShapeElemTokenMap = new SvXMLTokenMap(aGroupShapeElemTokenMap); } // if(!mpGroupShapeElemTokenMap) return *mpGroupShapeElemTokenMap; } const SvXMLTokenMap& XMLShapeImportHelper::GetFrameShapeElemTokenMap() { if(!mpFrameShapeElemTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aFrameShapeElemTokenMap[] = { { XML_NAMESPACE_DRAW, XML_TEXT_BOX, XML_TOK_FRAME_TEXT_BOX }, { XML_NAMESPACE_DRAW, XML_IMAGE, XML_TOK_FRAME_IMAGE }, { XML_NAMESPACE_DRAW, XML_OBJECT, XML_TOK_FRAME_OBJECT }, { XML_NAMESPACE_DRAW, XML_OBJECT_OLE, XML_TOK_FRAME_OBJECT_OLE }, { XML_NAMESPACE_DRAW, XML_PLUGIN, XML_TOK_FRAME_PLUGIN }, { XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, XML_TOK_FRAME_FLOATING_FRAME}, { XML_NAMESPACE_DRAW, XML_APPLET, XML_TOK_FRAME_APPLET }, { XML_NAMESPACE_TABLE, XML_TABLE, XML_TOK_FRAME_TABLE }, XML_TOKEN_MAP_END }; mpFrameShapeElemTokenMap = new SvXMLTokenMap(aFrameShapeElemTokenMap); } // if(!mpFrameShapeElemTokenMap) return *mpFrameShapeElemTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DSceneShapeElemTokenMap() { if(!mp3DSceneShapeElemTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DSceneShapeElemTokenMap[] = { { XML_NAMESPACE_DR3D, XML_SCENE, XML_TOK_3DSCENE_3DSCENE }, { XML_NAMESPACE_DR3D, XML_CUBE, XML_TOK_3DSCENE_3DCUBE }, { XML_NAMESPACE_DR3D, XML_SPHERE, XML_TOK_3DSCENE_3DSPHERE }, { XML_NAMESPACE_DR3D, XML_ROTATE, XML_TOK_3DSCENE_3DLATHE }, { XML_NAMESPACE_DR3D, XML_EXTRUDE, XML_TOK_3DSCENE_3DEXTRUDE }, XML_TOKEN_MAP_END }; mp3DSceneShapeElemTokenMap = new SvXMLTokenMap(a3DSceneShapeElemTokenMap); } // if(!mp3DSceneShapeElemTokenMap) return *mp3DSceneShapeElemTokenMap; } ////////////////////////////////////////////////////////////////////////////// /* const SvXMLTokenMap& XMLShapeImportHelper::GetShapeAttrTokenMap() { if(!mpShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aShapeAttrTokenMap[] = { { XML_NAMESPACE_DRAW, XML_NAME, XML_TOK_SHAPE_NAME }, { XML_NAMESPACE_DRAW, XML_STYLE_NAME, XML_TOK_SHAPE_DRAWSTYLE_NAME_GRAPHICS }, { XML_NAMESPACE_PRESENTATION, XML_CLASS, XML_TOK_SHAPE_PRESENTATION_CLASS }, { XML_NAMESPACE_PRESENTATION, XML_STYLE_NAME, XML_TOK_SHAPE_DRAWSTYLE_NAME_PRESENTATION }, { XML_NAMESPACE_SVG, XML_TRANSFORM, XML_TOK_SHAPE_TRANSFORM }, { XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TOK_SHAPE_IS_PLACEHOLDER }, { XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TOK_SHAPE_IS_USER_TRANSFORMED }, XML_TOKEN_MAP_END }; mpShapeAttrTokenMap = new SvXMLTokenMap(aShapeAttrTokenMap); } return *mpShapeAttrTokenMap; } */ ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DObjectAttrTokenMap() { if(!mp3DObjectAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DObjectAttrTokenMap[] = { { XML_NAMESPACE_DRAW, XML_STYLE_NAME, XML_TOK_3DOBJECT_DRAWSTYLE_NAME }, { XML_NAMESPACE_DR3D, XML_TRANSFORM, XML_TOK_3DOBJECT_TRANSFORM }, XML_TOKEN_MAP_END }; mp3DObjectAttrTokenMap = new SvXMLTokenMap(a3DObjectAttrTokenMap); } // if(!mp3DObjectAttrTokenMap) return *mp3DObjectAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DPolygonBasedAttrTokenMap() { if(!mp3DPolygonBasedAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DPolygonBasedAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_3DPOLYGONBASED_VIEWBOX }, { XML_NAMESPACE_SVG, XML_D, XML_TOK_3DPOLYGONBASED_D }, XML_TOKEN_MAP_END }; mp3DPolygonBasedAttrTokenMap = new SvXMLTokenMap(a3DPolygonBasedAttrTokenMap); } // if(!mp3DPolygonBasedAttrTokenMap) return *mp3DPolygonBasedAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DCubeObjectAttrTokenMap() { if(!mp3DCubeObjectAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DCubeObjectAttrTokenMap[] = { { XML_NAMESPACE_DR3D, XML_MIN_EDGE, XML_TOK_3DCUBEOBJ_MINEDGE }, { XML_NAMESPACE_DR3D, XML_MAX_EDGE, XML_TOK_3DCUBEOBJ_MAXEDGE }, XML_TOKEN_MAP_END }; mp3DCubeObjectAttrTokenMap = new SvXMLTokenMap(a3DCubeObjectAttrTokenMap); } // if(!mp3DCubeObjectAttrTokenMap) return *mp3DCubeObjectAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DSphereObjectAttrTokenMap() { if(!mp3DSphereObjectAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DSphereObjectAttrTokenMap[] = { { XML_NAMESPACE_DR3D, XML_CENTER, XML_TOK_3DSPHEREOBJ_CENTER }, { XML_NAMESPACE_DR3D, XML_SIZE, XML_TOK_3DSPHEREOBJ_SIZE }, XML_TOKEN_MAP_END }; mp3DSphereObjectAttrTokenMap = new SvXMLTokenMap(a3DSphereObjectAttrTokenMap); } // if(!mp3DSphereObjectAttrTokenMap) return *mp3DSphereObjectAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// /* const SvXMLTokenMap& XMLShapeImportHelper::GetRectShapeAttrTokenMap() { if(!mpRectShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aRectShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X, XML_TOK_RECTSHAPE_X }, { XML_NAMESPACE_SVG, XML_Y, XML_TOK_RECTSHAPE_Y }, { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_RECTSHAPE_WIDTH }, { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_RECTSHAPE_HEIGHT }, { XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, XML_TOK_RECTSHAPE_CORNER_RADIUS }, XML_TOKEN_MAP_END }; mpRectShapeAttrTokenMap = new SvXMLTokenMap(aRectShapeAttrTokenMap); } return *mpRectShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetLineShapeAttrTokenMap() { if(!mpLineShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aLineShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X1, XML_TOK_LINESHAPE_X1 }, { XML_NAMESPACE_SVG, XML_Y1, XML_TOK_LINESHAPE_Y1 }, { XML_NAMESPACE_SVG, XML_X2, XML_TOK_LINESHAPE_X2 }, { XML_NAMESPACE_SVG, XML_Y2, XML_TOK_LINESHAPE_Y2 }, XML_TOKEN_MAP_END }; mpLineShapeAttrTokenMap = new SvXMLTokenMap(aLineShapeAttrTokenMap); } return *mpLineShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetEllipseShapeAttrTokenMap() { if(!mpEllipseShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aEllipseShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_RX, XML_TOK_ELLIPSESHAPE_RX }, { XML_NAMESPACE_SVG, XML_RY, XML_TOK_ELLIPSESHAPE_RY }, { XML_NAMESPACE_SVG, XML_CX, XML_TOK_ELLIPSESHAPE_CX }, { XML_NAMESPACE_SVG, XML_CY, XML_TOK_ELLIPSESHAPE_CY }, { XML_NAMESPACE_SVG, XML_R, XML_TOK_ELLIPSESHAPE_R }, XML_TOKEN_MAP_END }; mpEllipseShapeAttrTokenMap = new SvXMLTokenMap(aEllipseShapeAttrTokenMap); } return *mpEllipseShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// */ const SvXMLTokenMap& XMLShapeImportHelper::GetPolygonShapeAttrTokenMap() { if(!mpPolygonShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aPolygonShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_POLYGONSHAPE_VIEWBOX }, { XML_NAMESPACE_DRAW, XML_POINTS, XML_TOK_POLYGONSHAPE_POINTS }, XML_TOKEN_MAP_END }; mpPolygonShapeAttrTokenMap = new SvXMLTokenMap(aPolygonShapeAttrTokenMap); } // if(!mpPolygonShapeAttrTokenMap) return *mpPolygonShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetPathShapeAttrTokenMap() { if(!mpPathShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aPathShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_PATHSHAPE_VIEWBOX }, { XML_NAMESPACE_SVG, XML_D, XML_TOK_PATHSHAPE_D }, XML_TOKEN_MAP_END }; mpPathShapeAttrTokenMap = new SvXMLTokenMap(aPathShapeAttrTokenMap); } // if(!mpPathShapeAttrTokenMap) return *mpPathShapeAttrTokenMap; } /* ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetTextBoxShapeAttrTokenMap() { if(!mpTextBoxShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aTextBoxShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X, XML_TOK_TEXTBOXSHAPE_X }, { XML_NAMESPACE_SVG, XML_Y, XML_TOK_TEXTBOXSHAPE_Y }, { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_TEXTBOXSHAPE_WIDTH }, { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_TEXTBOXSHAPE_HEIGHT }, XML_TOKEN_MAP_END }; mpTextBoxShapeAttrTokenMap = new SvXMLTokenMap(aTextBoxShapeAttrTokenMap); } return *mpTextBoxShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetControlShapeAttrTokenMap() { if(!mpControlShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aControlShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X, XML_TOK_CONTROLSHAPE_X }, { XML_NAMESPACE_SVG, XML_Y, XML_TOK_CONTROLSHAPE_Y }, { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_CONTROLSHAPE_WIDTH }, { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_CONTROLSHAPE_HEIGHT }, XML_TOKEN_MAP_END }; mpControlShapeAttrTokenMap = new SvXMLTokenMap(aControlShapeAttrTokenMap); } return *mpControlShapeAttrTokenMap; } */ ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DSceneShapeAttrTokenMap() { if(!mp3DSceneShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DSceneShapeAttrTokenMap[] = { { XML_NAMESPACE_DR3D, XML_TRANSFORM, XML_TOK_3DSCENESHAPE_TRANSFORM }, { XML_NAMESPACE_DR3D, XML_VRP, XML_TOK_3DSCENESHAPE_VRP }, { XML_NAMESPACE_DR3D, XML_VPN, XML_TOK_3DSCENESHAPE_VPN }, { XML_NAMESPACE_DR3D, XML_VUP, XML_TOK_3DSCENESHAPE_VUP }, { XML_NAMESPACE_DR3D, XML_PROJECTION, XML_TOK_3DSCENESHAPE_PROJECTION }, { XML_NAMESPACE_DR3D, XML_DISTANCE, XML_TOK_3DSCENESHAPE_DISTANCE }, { XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, XML_TOK_3DSCENESHAPE_FOCAL_LENGTH }, { XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, XML_TOK_3DSCENESHAPE_SHADOW_SLANT }, { XML_NAMESPACE_DR3D, XML_SHADE_MODE, XML_TOK_3DSCENESHAPE_SHADE_MODE }, { XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, XML_TOK_3DSCENESHAPE_AMBIENT_COLOR }, { XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, XML_TOK_3DSCENESHAPE_LIGHTING_MODE }, XML_TOKEN_MAP_END }; mp3DSceneShapeAttrTokenMap = new SvXMLTokenMap(a3DSceneShapeAttrTokenMap); } // if(!mp3DSceneShapeAttrTokenMap) return *mp3DSceneShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::Get3DLightAttrTokenMap() { if(!mp3DLightAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry a3DLightAttrTokenMap[] = { { XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, XML_TOK_3DLIGHT_DIFFUSE_COLOR }, { XML_NAMESPACE_DR3D, XML_DIRECTION, XML_TOK_3DLIGHT_DIRECTION }, { XML_NAMESPACE_DR3D, XML_ENABLED, XML_TOK_3DLIGHT_ENABLED }, { XML_NAMESPACE_DR3D, XML_SPECULAR, XML_TOK_3DLIGHT_SPECULAR }, XML_TOKEN_MAP_END }; mp3DLightAttrTokenMap = new SvXMLTokenMap(a3DLightAttrTokenMap); } // if(!mp3DLightAttrTokenMap) return *mp3DLightAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// /* const SvXMLTokenMap& XMLShapeImportHelper::GetPageShapeAttrTokenMap() { if(!mpPageShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aPageShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X, XML_TOK_PAGESHAPE_X }, { XML_NAMESPACE_SVG, XML_Y, XML_TOK_PAGESHAPE_Y }, { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_PAGESHAPE_WIDTH }, { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_PAGESHAPE_HEIGHT }, XML_TOKEN_MAP_END }; mpPageShapeAttrTokenMap = new SvXMLTokenMap(aPageShapeAttrTokenMap); } return *mpPageShapeAttrTokenMap; } ////////////////////////////////////////////////////////////////////////////// const SvXMLTokenMap& XMLShapeImportHelper::GetGraphicObjectShapeAttrTokenMap() { if(!mpGraphicObjectShapeAttrTokenMap) { static __FAR_DATA SvXMLTokenMapEntry aGraphicObjectShapeAttrTokenMap[] = { { XML_NAMESPACE_SVG, XML_X, XML_TOK_GOSHAPE_X }, { XML_NAMESPACE_SVG, XML_Y, XML_TOK_GOSHAPE_Y }, { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_GOSHAPE_WIDTH }, { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_GOSHAPE_HEIGHT }, { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_GOSHAPE_URL }, XML_TOKEN_MAP_END }; mpGraphicObjectShapeAttrTokenMap = new SvXMLTokenMap(aGraphicObjectShapeAttrTokenMap); } return *mpGraphicObjectShapeAttrTokenMap; } */ ////////////////////////////////////////////////////////////////////////////// SvXMLShapeContext* XMLShapeImportHelper::Create3DSceneChildContext( SvXMLImport& rImport, USHORT p_nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList>& xAttrList, uno::Reference< drawing::XShapes >& rShapes) { SdXMLShapeContext *pContext = 0L; if(rShapes.is()) { const SvXMLTokenMap& rTokenMap = Get3DSceneShapeElemTokenMap(); switch(rTokenMap.Get(p_nPrefix, rLocalName)) { case XML_TOK_3DSCENE_3DSCENE: { // dr3d:3dscene inside dr3d:3dscene context pContext = new SdXML3DSceneShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False); break; } case XML_TOK_3DSCENE_3DCUBE: { // dr3d:3dcube inside dr3d:3dscene context pContext = new SdXML3DCubeObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False); break; } case XML_TOK_3DSCENE_3DSPHERE: { // dr3d:3dsphere inside dr3d:3dscene context pContext = new SdXML3DSphereObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False); break; } case XML_TOK_3DSCENE_3DLATHE: { // dr3d:3dlathe inside dr3d:3dscene context pContext = new SdXML3DLatheObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False); break; } case XML_TOK_3DSCENE_3DEXTRUDE: { // dr3d:3dextrude inside dr3d:3dscene context pContext = new SdXML3DExtrudeObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False); break; } } } // now parse the attribute list and call the child context for each unknown attribute sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; for(sal_Int16 a(0); a < nAttrCount; a++) { const OUString& rAttrName = xAttrList->getNameByIndex(a); OUString aLocalName; sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName); const OUString aValue( xAttrList->getValueByIndex(a) ); pContext->processAttribute( nPrefix, aLocalName, aValue ); } return pContext; } ////////////////////////////////////////////////////////////////////////////// void XMLShapeImportHelper::SetStylesContext(SvXMLStylesContext* pNew) { mpStylesContext = pNew; mpStylesContext->AddRef(); } ////////////////////////////////////////////////////////////////////////////// void XMLShapeImportHelper::SetAutoStylesContext(SvXMLStylesContext* pNew) { mpAutoStylesContext = pNew; mpAutoStylesContext->AddRef(); } ////////////////////////////////////////////////////////////////////////////// SvXMLShapeContext* XMLShapeImportHelper::CreateGroupChildContext( SvXMLImport& rImport, USHORT p_nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList>& xAttrList, uno::Reference< drawing::XShapes >& rShapes, sal_Bool bTemporaryShape) { SdXMLShapeContext *pContext = 0L; const SvXMLTokenMap& rTokenMap = GetGroupShapeElemTokenMap(); sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; switch(rTokenMap.Get(p_nPrefix, rLocalName)) { case XML_TOK_GROUP_GROUP: { // draw:g inside group context (RECURSIVE) pContext = new SdXMLGroupShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape); break; } case XML_TOK_GROUP_3DSCENE: { // dr3d:3dscene inside group context pContext = new SdXML3DSceneShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape); break; } case XML_TOK_GROUP_RECT: { // draw:rect inside group context pContext = new SdXMLRectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_LINE: { // draw:line inside group context pContext = new SdXMLLineShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CIRCLE: case XML_TOK_GROUP_ELLIPSE: { // draw:circle or draw:ellipse inside group context pContext = new SdXMLEllipseShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_POLYGON: case XML_TOK_GROUP_POLYLINE: { // draw:polygon or draw:polyline inside group context pContext = new SdXMLPolygonShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, rTokenMap.Get(p_nPrefix, rLocalName) == XML_TOK_GROUP_POLYGON ? TRUE : FALSE, bTemporaryShape ); break; } case XML_TOK_GROUP_PATH: { // draw:path inside group context pContext = new SdXMLPathShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape); break; } case XML_TOK_GROUP_FRAME: { // text:text-box inside group context pContext = new SdXMLFrameShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CONTROL: { // draw:control inside group context pContext = new SdXMLControlShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CONNECTOR: { // draw:connector inside group context pContext = new SdXMLConnectorShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_MEASURE: { // draw:measure inside group context pContext = new SdXMLMeasureShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_PAGE: { // draw:page inside group context pContext = new SdXMLPageShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CAPTION: case XML_TOK_GROUP_ANNOTATION: { // draw:caption inside group context pContext = new SdXMLCaptionShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CHART: { // chart:chart inside group context pContext = new SdXMLChartShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, bTemporaryShape ); break; } case XML_TOK_GROUP_CUSTOM_SHAPE: { // draw:customshape pContext = new SdXMLCustomShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_GROUP_A: { return new SdXMLShapeLinkContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes ); } // add other shapes here... default: return new SvXMLShapeContext( rImport, p_nPrefix, rLocalName, bTemporaryShape ); } // now parse the attribute list and call the child context for each unknown attribute for(sal_Int16 a(0); a < nAttrCount; a++) { const OUString& rAttrName = xAttrList->getNameByIndex(a); OUString aLocalName; sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName); const OUString aValue( xAttrList->getValueByIndex(a) ); pContext->processAttribute( nPrefix, aLocalName, aValue ); } return pContext; } // This method is called from SdXMLFrameContext to create children of drawe:frame SvXMLShapeContext* XMLShapeImportHelper::CreateFrameChildContext( SvXMLImport& rImport, USHORT p_nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList>& rAttrList, uno::Reference< drawing::XShapes >& rShapes, const uno::Reference< xml::sax::XAttributeList>& rFrameAttrList) { SdXMLShapeContext *pContext = 0L; const SvXMLTokenMap& rTokenMap = GetFrameShapeElemTokenMap(); SvXMLAttributeList *pAttrList = new SvXMLAttributeList( rAttrList ); if( rFrameAttrList.is() ) pAttrList->AppendAttributeList( rFrameAttrList ); uno::Reference < xml::sax::XAttributeList > xAttrList = pAttrList; switch(rTokenMap.Get(p_nPrefix, rLocalName)) { case XML_TOK_FRAME_TEXT_BOX: { // text:text-box inside group context pContext = new SdXMLTextBoxShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_FRAME_IMAGE: { // office:image inside group context pContext = new SdXMLGraphicObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_FRAME_OBJECT: case XML_TOK_FRAME_OBJECT_OLE: { // draw:object or draw:object_ole pContext = new SdXMLObjectShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_FRAME_TABLE: { // draw:object or draw:object_ole if( rImport.IsTableShapeSupported() ) pContext = new SdXMLTableShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes ); break; } case XML_TOK_FRAME_PLUGIN: { // draw:plugin pContext = new SdXMLPluginShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_FRAME_FLOATING_FRAME: { // draw:floating-frame pContext = new SdXMLFloatingFrameShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } case XML_TOK_FRAME_APPLET: { // draw:applet pContext = new SdXMLAppletShapeContext( rImport, p_nPrefix, rLocalName, xAttrList, rShapes, sal_False ); break; } // add other shapes here... default: break; } if( pContext ) { // now parse the attribute list and call the child context for each unknown attribute sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; for(sal_Int16 a(0); a < nAttrCount; a++) { const OUString& rAttrName = xAttrList->getNameByIndex(a); OUString aLocalName; sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName); const OUString aValue( xAttrList->getValueByIndex(a) ); pContext->processAttribute( nPrefix, aLocalName, aValue ); } } return pContext; } SvXMLImportContext *XMLShapeImportHelper::CreateFrameChildContext( SvXMLImportContext *pThisContext, USHORT nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList>& xAttrList ) { SvXMLImportContext * pContext = NULL; SdXMLFrameShapeContext *pFrameContext = PTR_CAST( SdXMLFrameShapeContext, pThisContext ); if( pFrameContext ) pContext = pFrameContext->CreateChildContext( nPrefix, rLocalName, xAttrList ); return pContext; } /** this function is called whenever the implementation classes like to add this new shape to the given XShapes. */ void XMLShapeImportHelper::addShape( uno::Reference< drawing::XShape >& rShape, const uno::Reference< xml::sax::XAttributeList >&, uno::Reference< drawing::XShapes >& rShapes) { if( rShape.is() && rShapes.is() ) { // add new shape to parent rShapes->add( rShape ); } } /** this function is called whenever the implementation classes have finished importing a shape to the given XShapes. The shape is already inserted into its XShapes and all properties and styles are set. */ void XMLShapeImportHelper::finishShape( com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& rShape, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >&, com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >&) { // --> OD 2004-08-10 #i28749#, #i36248# - set property // to , if it exists and the import states that // the shape positioning attributes are in horizontal left-to-right // layout. This is the case for the OpenOffice.org file format. // This setting is done for Writer documents, because the property // only exists at service com::sun::star::text::Shape - the Writer // UNO service for shapes. // The value indicates that the positioning attributes are given // in horizontal left-to-right layout. The property is evaluated // during the first positioning of the shape in order to convert // the shape position given in the OpenOffice.org file format to // the one for the OASIS Open Office file format. uno::Reference< beans::XPropertySet > xPropSet(rShape, uno::UNO_QUERY); if ( xPropSet.is() ) { if ( mrImporter.IsShapePositionInHoriL2R() && xPropSet->getPropertySetInfo()->hasPropertyByName( OUString(RTL_CONSTASCII_USTRINGPARAM("PositionLayoutDir"))) ) { uno::Any aPosLayoutDir; aPosLayoutDir <<= text::PositionLayoutDir::PositionInHoriL2R; xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("PositionLayoutDir")), aPosLayoutDir ); } } // <-- } // helper functions for z-order sorting struct ZOrderHint { sal_Int32 nIs; sal_Int32 nShould; int operator<(const ZOrderHint& rComp) const { return nShould < rComp.nShould; } }; class ShapeSortContext { public: uno::Reference< drawing::XShapes > mxShapes; list maZOrderList; list maUnsortedList; sal_Int32 mnCurrentZ; ShapeSortContext* mpParentContext; const OUString msZOrder; ShapeSortContext( uno::Reference< drawing::XShapes >& rShapes, ShapeSortContext* pParentContext = NULL ); void moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos ); }; ShapeSortContext::ShapeSortContext( uno::Reference< drawing::XShapes >& rShapes, ShapeSortContext* pParentContext ) : mxShapes( rShapes ), mnCurrentZ( 0 ), mpParentContext( pParentContext ), msZOrder(RTL_CONSTASCII_USTRINGPARAM("ZOrder")) { } void ShapeSortContext::moveShape( sal_Int32 nSourcePos, sal_Int32 nDestPos ) { uno::Any aAny( mxShapes->getByIndex( nSourcePos ) ); uno::Reference< beans::XPropertySet > xPropSet; aAny >>= xPropSet; if( xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName( msZOrder ) ) { aAny <<= nDestPos; xPropSet->setPropertyValue( msZOrder, aAny ); list::iterator aIter = maZOrderList.begin(); list::iterator aEnd = maZOrderList.end(); while( aIter != aEnd ) { if( (*aIter).nIs < nSourcePos ) { DBG_ASSERT( (*aIter).nIs >= nDestPos, "Shape sorting failed" ); (*aIter).nIs++; } aIter++; } aIter = maUnsortedList.begin(); aEnd = maUnsortedList.end(); while( aIter != aEnd ) { if( (*aIter).nIs < nSourcePos ) { DBG_ASSERT( (*aIter).nIs >= nDestPos, "shape sorting failed" ); (*aIter).nIs++; } aIter++; } } } void XMLShapeImportHelper::pushGroupForSorting( uno::Reference< drawing::XShapes >& rShapes ) { mpImpl->mpSortContext = new ShapeSortContext( rShapes, mpImpl->mpSortContext ); } void XMLShapeImportHelper::popGroupAndSort() { DBG_ASSERT( mpImpl->mpSortContext, "No context to sort!" ); if( mpImpl->mpSortContext == NULL ) return; try { list& rZList = mpImpl->mpSortContext->maZOrderList; list& rUnsortedList = mpImpl->mpSortContext->maUnsortedList; // sort shapes if( !rZList.empty() ) { // only do something if we have shapes to sort // check if there are more shapes than inserted with ::shapeWithZIndexAdded() // This can happen if there where already shapes on the page before import // Since the writer may delete some of this shapes during import, we need // to do this here and not in our c'tor anymore // check if we have more shapes than we know of sal_Int32 nCount = mpImpl->mpSortContext->mxShapes->getCount(); nCount -= rZList.size(); nCount -= rUnsortedList.size(); if( nCount > 0 ) { // first update offsets of added shapes list::iterator aIter( rZList.begin() ); while( aIter != rZList.end() ) (*aIter++).nIs += nCount; aIter = rUnsortedList.begin(); while( aIter != rUnsortedList.end() ) (*aIter++).nIs += nCount; // second add the already existing shapes in the unsorted list ZOrderHint aNewHint; do { nCount--; aNewHint.nIs = nCount; aNewHint.nShould = -1; rUnsortedList.insert(rUnsortedList.begin(), aNewHint); } while( nCount ); } // sort z ordered shapes rZList.sort(); // this is the current index, all shapes before that // index are finished sal_Int32 nIndex = 0; while( !rZList.empty() ) { list::iterator aIter( rZList.begin() ); while( nIndex < (*aIter).nShould && !rUnsortedList.empty() ) { ZOrderHint aGapHint( *rUnsortedList.begin() ); rUnsortedList.pop_front(); mpImpl->mpSortContext->moveShape( aGapHint.nIs, nIndex++ ); } if( (*aIter).nIs != nIndex ) mpImpl->mpSortContext->moveShape( (*aIter).nIs, nIndex ); rZList.pop_front(); nIndex++; } } } catch( uno::Exception& ) { DBG_ERROR("exception while sorting shapes, sorting failed!"); } // put parent on top and delete current context, were done ShapeSortContext* pContext = mpImpl->mpSortContext; mpImpl->mpSortContext = pContext->mpParentContext; delete pContext; } void XMLShapeImportHelper::shapeWithZIndexAdded( com::sun::star::uno::Reference< com::sun::star::drawing::XShape >&, sal_Int32 nZIndex ) { if( mpImpl->mpSortContext) { ZOrderHint aNewHint; aNewHint.nIs = mpImpl->mpSortContext->mnCurrentZ++; aNewHint.nShould = nZIndex; if( nZIndex == -1 ) { // don't care, so add to unsorted list mpImpl->mpSortContext->maUnsortedList.push_back(aNewHint); } else { // insert into sort list mpImpl->mpSortContext->maZOrderList.push_back(aNewHint); } } } void XMLShapeImportHelper::addShapeConnection( com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& rConnectorShape, sal_Bool bStart, const rtl::OUString& rDestShapeId, sal_Int32 nDestGlueId ) { ConnectionHint aHint; aHint.mxConnector = rConnectorShape; aHint.bStart = bStart; aHint.aDestShapeId = rDestShapeId; aHint.nDestGlueId = nDestGlueId; mpImpl->maConnections.push_back( aHint ); } void XMLShapeImportHelper::restoreConnections() { if( !mpImpl->maConnections.empty() ) { uno::Any aAny; const vector::size_type nCount = mpImpl->maConnections.size(); for( vector::size_type i = 0; i < nCount; i++ ) { ConnectionHint& rHint = mpImpl->maConnections[i]; uno::Reference< beans::XPropertySet > xConnector( rHint.mxConnector, uno::UNO_QUERY ); if( xConnector.is() ) { // #86637# remember line deltas uno::Any aLine1Delta; uno::Any aLine2Delta; uno::Any aLine3Delta; OUString aStr1(RTL_CONSTASCII_USTRINGPARAM("EdgeLine1Delta")); OUString aStr2(RTL_CONSTASCII_USTRINGPARAM("EdgeLine2Delta")); OUString aStr3(RTL_CONSTASCII_USTRINGPARAM("EdgeLine3Delta")); aLine1Delta = xConnector->getPropertyValue(aStr1); aLine2Delta = xConnector->getPropertyValue(aStr2); aLine3Delta = xConnector->getPropertyValue(aStr3); // #86637# simply setting these values WILL force the connector to do // an new layout promptly. So the line delta values have to be rescued // and restored around connector changes. uno::Reference< drawing::XShape > xShape( mrImporter.getInterfaceToIdentifierMapper().getReference( rHint.aDestShapeId ), uno::UNO_QUERY ); if( xShape.is() ) { aAny <<= xShape; xConnector->setPropertyValue( rHint.bStart ? msStartShape : msEndShape, aAny ); sal_Int32 nGlueId = rHint.nDestGlueId < 4 ? rHint.nDestGlueId : getGluePointId( xShape, rHint.nDestGlueId ); aAny <<= nGlueId; xConnector->setPropertyValue( rHint.bStart ? msStartGluePointIndex : msEndGluePointIndex, aAny ); } // #86637# restore line deltas xConnector->setPropertyValue(aStr1, aLine1Delta ); xConnector->setPropertyValue(aStr2, aLine2Delta ); xConnector->setPropertyValue(aStr3, aLine3Delta ); } } mpImpl->maConnections.clear(); } } SvXMLImportPropertyMapper* XMLShapeImportHelper::CreateShapePropMapper( const uno::Reference< frame::XModel>& rModel, SvXMLImport& rImport ) { UniReference< XMLPropertyHandlerFactory > xFactory = new XMLSdPropHdlFactory( rModel, rImport ); UniReference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( xFactory ); SvXMLImportPropertyMapper* pResult = new SvXMLImportPropertyMapper( xMapper, rImport ); // chain text attributes pResult->ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper( rImport ) ); return pResult; } /** creates a shape property set mapper that can be used for non shape elements. Only current feature is that the ShapeUserDefinedAttributes property is not included in this one. */ SvXMLImportPropertyMapper* XMLShapeImportHelper::CreateExternalShapePropMapper( const uno::Reference< frame::XModel>& rModel, SvXMLImport& rImport ) { UniReference< XMLPropertyHandlerFactory > xFactory = new XMLSdPropHdlFactory( rModel, rImport ); UniReference < XMLPropertySetMapper > xMapper = new XMLShapePropertySetMapper( xFactory, 1 ); SvXMLImportPropertyMapper* pResult = new SvXMLImportPropertyMapper( xMapper, rImport ); // chain text attributes pResult->ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper( rImport ) ); return pResult; } /** adds a mapping for a glue point identifier from an xml file to the identifier created after inserting the new glue point into the core. The saved mappings can be retrieved by getGluePointId() */ void XMLShapeImportHelper::addGluePointMapping( com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape, sal_Int32 nSourceId, sal_Int32 nDestinnationId ) { if( mpPageContext ) mpPageContext->maShapeGluePointsMap[xShape][nSourceId] = nDestinnationId; } /** moves all current DestinationId's by n */ void XMLShapeImportHelper::moveGluePointMapping( const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape, const sal_Int32 n ) { if( mpPageContext ) { ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) ); if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() ) { GluePointIdMap::iterator aShapeIdIter = (*aShapeIter).second.begin(); GluePointIdMap::iterator aShapeIdEnd = (*aShapeIter).second.end(); while ( aShapeIdIter != aShapeIdEnd ) { if ( (*aShapeIdIter).second != -1 ) (*aShapeIdIter).second += n; aShapeIdIter++; } } } } /** retrieves a mapping for a glue point identifier from the current xml file to the identifier created after inserting the new glue point into the core. The mapping must be initialized first with addGluePointMapping() */ sal_Int32 XMLShapeImportHelper::getGluePointId( com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape, sal_Int32 nSourceId ) { if( mpPageContext ) { ShapeGluePointsMap::iterator aShapeIter( mpPageContext->maShapeGluePointsMap.find( xShape ) ); if( aShapeIter != mpPageContext->maShapeGluePointsMap.end() ) { GluePointIdMap::iterator aIdIter = (*aShapeIter).second.find(nSourceId); if( aIdIter != (*aShapeIter).second.end() ) return (*aIdIter).second; } } return -1; } /** this method must be calling before the first shape is imported for the given page */ void XMLShapeImportHelper::startPage( com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes ) { XMLShapeImportPageContextImpl* pOldContext = mpPageContext; mpPageContext = new XMLShapeImportPageContextImpl(); mpPageContext->mpNext = pOldContext; mpPageContext->mxShapes = rShapes; } /** this method must be calling after the last shape is imported for the given page */ void XMLShapeImportHelper::endPage( com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& #ifdef DBG_UTIL rShapes #endif ) { DBG_ASSERT( mpPageContext && (mpPageContext->mxShapes == rShapes), "wrong call to endPage(), no startPage called or wrong page" ); if( NULL == mpPageContext ) return; restoreConnections(); XMLShapeImportPageContextImpl* pNextContext = mpPageContext->mpNext; delete mpPageContext; mpPageContext = pNextContext; } // #88546# /** defines if the import should increment the progress bar or not */ void XMLShapeImportHelper::enableHandleProgressBar( sal_Bool bEnable ) { mpImpl->mbHandleProgressBar = bEnable; } sal_Bool XMLShapeImportHelper::IsHandleProgressBarEnabled() const { return mpImpl->mbHandleProgressBar; } /** queries the capability of the current model to create presentation shapes */ sal_Bool XMLShapeImportHelper::IsPresentationShapesSupported() { return mpImpl->mbIsPresentationShapesSupported; } const rtl::Reference< XMLTableImport >& XMLShapeImportHelper::GetShapeTableImport() { if( !mxShapeTableImport.is() ) { rtl::Reference< XMLPropertyHandlerFactory > xFactory( new XMLSdPropHdlFactory( mrImporter.GetModel(), mrImporter ) ); rtl::Reference< XMLPropertySetMapper > xPropertySetMapper( new XMLShapePropertySetMapper( xFactory.get() ) ); mxShapeTableImport = new XMLTableImport( mrImporter, xPropertySetMapper, xFactory ); } return mxShapeTableImport; } void SvXMLShapeContext::setHyperlink( const OUString& rHyperlink ) { msHyperlink = rHyperlink; }