| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_xmloff.hxx" | |
| #include <tools/debug.hxx> | |
| #include <com/sun/star/text/PositionLayoutDir.hpp> | |
| #include <com/sun/star/chart/XChartDocument.hpp> | |
| #include "unointerfacetouniqueidentifiermapper.hxx" | |
| #include <list> | |
| #ifndef _XMLOFF_SHAPEIMPORT_HXX | |
| #include <xmloff/shapeimport.hxx> | |
| #endif | |
| #include <xmloff/xmltkmap.hxx> | |
| #include "xmloff/xmlnmspe.hxx" | |
| #include <xmloff/xmltoken.hxx> | |
| #include "ximpstyl.hxx" | |
| #include "ximpshap.hxx" | |
| #include "sdpropls.hxx" | |
| #include <xmloff/xmlprmap.hxx> | |
| #include "ximp3dscene.hxx" | |
| #include "ximp3dobject.hxx" | |
| #include "ximpgrp.hxx" | |
| #include "ximplink.hxx" | |
| #include <map> | |
| #include <vector> | |
| 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<sal_Int32,com::sun::star::uno::Reference< com::sun::star::drawing::XShape >,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<sal_Int32,sal_Int32,ltint32> 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<ConnectionHint> maConnections; | |
| // #88546# possibility to switch 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 sal_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)); | |
| // 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, | |
| sal_uInt16 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, | |
| sal_uInt16 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 ? sal_True : sal_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, | |
| sal_uInt16 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, | |
| sal_uInt16 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 <PositionLayoutDir> | |
| // to <PositionInHoriL2R>, 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<ZOrderHint> maZOrderList; | |
| list<ZOrderHint> 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<ZOrderHint>::iterator aIter = maZOrderList.begin(); | |
| list<ZOrderHint>::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<ZOrderHint>& rZList = mpImpl->mpSortContext->maZOrderList; | |
| list<ZOrderHint>& 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<ZOrderHint>::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<ZOrderHint>::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<ConnectionHint>::size_type nCount = mpImpl->maConnections.size(); | |
| for( vector<ConnectionHint>::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; | |
| } | |
| /** find mapping for given DestinationID. This allows to extract the original draw:id imported with a draw:glue-point */ | |
| sal_Int32 XMLShapeImportHelper::findGluePointMapping( | |
| const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape, | |
| sal_Int32 nDestinnationId ) const | |
| { | |
| 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 == nDestinnationId ) | |
| { | |
| return (*aShapeIdIter).first; | |
| } | |
| aShapeIdIter++; | |
| } | |
| } | |
| } | |
| return -1; | |
| } | |
| /** 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( const 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; | |
| } |