| /************************************************************** | |
| * | |
| * 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/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/text/TextContentAnchorType.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/text/XTextFrame.hpp> | |
| #include <com/sun/star/container/XNamed.hpp> | |
| #include <com/sun/star/text/SizeType.hpp> | |
| #include <com/sun/star/drawing/XShape.hpp> | |
| #include <com/sun/star/document/XEventsSupplier.hpp> | |
| #include <com/sun/star/document/XEmbeddedObjectSupplier.hpp> | |
| #include <com/sun/star/io/XOutputStream.hpp> | |
| #include <com/sun/star/text/HoriOrientation.hpp> | |
| #include <com/sun/star/text/VertOrientation.hpp> | |
| #include <xmloff/xmlimp.hxx> | |
| #include <xmloff/xmltoken.hxx> | |
| #include "xmloff/xmlnmspe.hxx" | |
| #include <xmloff/nmspmap.hxx> | |
| #include <xmloff/xmluconv.hxx> | |
| #include "XMLAnchorTypePropHdl.hxx" | |
| #include "XMLEmbeddedObjectImportContext.hxx" | |
| #include <xmloff/XMLBase64ImportContext.hxx> | |
| #include "XMLReplacementImageContext.hxx" | |
| #include <xmloff/prstylei.hxx> | |
| #include "xmloff/i18nmap.hxx" | |
| #include "xexptran.hxx" | |
| #include <xmloff/shapeimport.hxx> | |
| #include <xmloff/XMLEventsImportContext.hxx> | |
| #include "XMLImageMapContext.hxx" | |
| #include "XMLTextFrameContext.hxx" | |
| #include "XMLTextListBlockContext.hxx" | |
| #include "XMLTextListItemContext.hxx" | |
| #include <xmloff/attrlist.hxx> | |
| #include <comphelper/stl_types.hxx> | |
| #include <basegfx/polygon/b2dpolygon.hxx> | |
| #include <basegfx/polygon/b2dpolygontools.hxx> | |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> | |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> | |
| #include <map> | |
| using ::rtl::OUString; | |
| using ::rtl::OUStringBuffer; | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::text; | |
| using namespace ::com::sun::star::xml::sax; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::drawing; | |
| using namespace ::com::sun::star::document; | |
| using namespace ::xmloff::token; | |
| using ::com::sun::star::document::XEventsSupplier; | |
| #define XML_TEXT_FRAME_TEXTBOX 1 | |
| #define XML_TEXT_FRAME_GRAPHIC 2 | |
| #define XML_TEXT_FRAME_OBJECT 3 | |
| #define XML_TEXT_FRAME_OBJECT_OLE 4 | |
| #define XML_TEXT_FRAME_APPLET 5 | |
| #define XML_TEXT_FRAME_PLUGIN 6 | |
| #define XML_TEXT_FRAME_FLOATING_FRAME 7 | |
| typedef ::std::map < const ::rtl::OUString, ::rtl::OUString, ::comphelper::UStringLess> ParamMap; | |
| class XMLTextFrameContextHyperlink_Impl | |
| { | |
| OUString sHRef; | |
| OUString sName; | |
| OUString sTargetFrameName; | |
| sal_Bool bMap; | |
| public: | |
| inline XMLTextFrameContextHyperlink_Impl( const OUString& rHRef, | |
| const OUString& rName, | |
| const OUString& rTargetFrameName, | |
| sal_Bool bMap ); | |
| const OUString& GetHRef() const { return sHRef; } | |
| const OUString& GetName() const { return sName; } | |
| const OUString& GetTargetFrameName() const { return sTargetFrameName; } | |
| sal_Bool GetMap() const { return bMap; } | |
| }; | |
| inline XMLTextFrameContextHyperlink_Impl::XMLTextFrameContextHyperlink_Impl( | |
| const OUString& rHRef, const OUString& rName, | |
| const OUString& rTargetFrameName, sal_Bool bM ) : | |
| sHRef( rHRef ), | |
| sName( rName ), | |
| sTargetFrameName( rTargetFrameName ), | |
| bMap( bM ) | |
| { | |
| } | |
| // --> OD 2009-07-22 #i73249# | |
| class XMLTextFrameTitleOrDescContext_Impl : public SvXMLImportContext | |
| { | |
| OUString& mrTitleOrDesc; | |
| public: | |
| TYPEINFO(); | |
| XMLTextFrameTitleOrDescContext_Impl( SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, | |
| const ::rtl::OUString& rLName, | |
| OUString& rTitleOrDesc ); | |
| virtual ~XMLTextFrameTitleOrDescContext_Impl(); | |
| virtual void Characters( const OUString& rText ); | |
| }; | |
| TYPEINIT1( XMLTextFrameTitleOrDescContext_Impl, SvXMLImportContext ); | |
| XMLTextFrameTitleOrDescContext_Impl::XMLTextFrameTitleOrDescContext_Impl( | |
| SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, | |
| const OUString& rLName, | |
| OUString& rTitleOrDesc ) | |
| : SvXMLImportContext( rImport, nPrfx, rLName ) | |
| , mrTitleOrDesc( rTitleOrDesc ) | |
| { | |
| } | |
| XMLTextFrameTitleOrDescContext_Impl::~XMLTextFrameTitleOrDescContext_Impl() | |
| { | |
| } | |
| void XMLTextFrameTitleOrDescContext_Impl::Characters( const OUString& rText ) | |
| { | |
| mrTitleOrDesc += rText; | |
| } | |
| // <-- | |
| // ------------------------------------------------------------------------ | |
| class XMLTextFrameParam_Impl : public SvXMLImportContext | |
| { | |
| public: | |
| TYPEINFO(); | |
| XMLTextFrameParam_Impl( SvXMLImport& rImport, sal_uInt16 nPrfx, | |
| const ::rtl::OUString& rLName, | |
| const ::com::sun::star::uno::Reference< | |
| ::com::sun::star::xml::sax::XAttributeList > & xAttrList, | |
| sal_uInt16 nType, | |
| ParamMap &rParamMap); | |
| virtual ~XMLTextFrameParam_Impl(); | |
| }; | |
| TYPEINIT1( XMLTextFrameParam_Impl, SvXMLImportContext ); | |
| XMLTextFrameParam_Impl::~XMLTextFrameParam_Impl() | |
| { | |
| } | |
| XMLTextFrameParam_Impl::XMLTextFrameParam_Impl( | |
| SvXMLImport& rImport, sal_uInt16 nPrfx, | |
| const ::rtl::OUString& rLName, | |
| const ::com::sun::star::uno::Reference< | |
| ::com::sun::star::xml::sax::XAttributeList > & xAttrList, | |
| sal_uInt16 /*nType*/, | |
| ParamMap &rParamMap): | |
| SvXMLImportContext( rImport, nPrfx, rLName ) | |
| { | |
| OUString sName, sValue; | |
| sal_Bool bFoundValue = sal_False; // to allow empty values | |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; | |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) | |
| { | |
| const OUString& rAttrName = xAttrList->getNameByIndex( i ); | |
| const OUString& rValue = xAttrList->getValueByIndex( i ); | |
| OUString aLocalName; | |
| sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName ); | |
| if ( XML_NAMESPACE_DRAW == nPrefix ) | |
| { | |
| if( IsXMLToken(aLocalName, XML_VALUE) ) | |
| { | |
| sValue = rValue; | |
| bFoundValue=sal_True; | |
| } | |
| else if( IsXMLToken(aLocalName, XML_NAME) ) | |
| { | |
| sName = rValue; | |
| } | |
| } | |
| } | |
| if (sName.getLength() && bFoundValue ) | |
| rParamMap[sName] = sValue; | |
| } | |
| class XMLTextFrameContourContext_Impl : public SvXMLImportContext | |
| { | |
| Reference < XPropertySet > xPropSet; | |
| public: | |
| TYPEINFO(); | |
| XMLTextFrameContourContext_Impl( SvXMLImport& rImport, sal_uInt16 nPrfx, | |
| const ::rtl::OUString& rLName, | |
| const ::com::sun::star::uno::Reference< | |
| ::com::sun::star::xml::sax::XAttributeList > & xAttrList, | |
| const Reference < XPropertySet >& rPropSet, | |
| sal_Bool bPath ); | |
| virtual ~XMLTextFrameContourContext_Impl(); | |
| }; | |
| TYPEINIT1( XMLTextFrameContourContext_Impl, SvXMLImportContext ); | |
| XMLTextFrameContourContext_Impl::XMLTextFrameContourContext_Impl( | |
| SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, const OUString& rLName, | |
| const Reference< XAttributeList > & xAttrList, | |
| const Reference < XPropertySet >& rPropSet, | |
| sal_Bool bPath ) : | |
| SvXMLImportContext( rImport, nPrfx, rLName ), | |
| xPropSet( rPropSet ) | |
| { | |
| OUString sD, sPoints, sViewBox; | |
| sal_Bool bPixelWidth = sal_False, bPixelHeight = sal_False; | |
| sal_Bool bAuto = sal_False; | |
| sal_Int32 nWidth = 0; | |
| sal_Int32 nHeight = 0; | |
| const SvXMLTokenMap& rTokenMap = | |
| GetImport().GetTextImport()->GetTextContourAttrTokenMap(); | |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; | |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) | |
| { | |
| const OUString& rAttrName = xAttrList->getNameByIndex( i ); | |
| const OUString& rValue = xAttrList->getValueByIndex( i ); | |
| OUString aLocalName; | |
| sal_uInt16 nPrefix = | |
| GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, | |
| &aLocalName ); | |
| switch( rTokenMap.Get( nPrefix, aLocalName ) ) | |
| { | |
| case XML_TOK_TEXT_CONTOUR_VIEWBOX: | |
| sViewBox = rValue; | |
| break; | |
| case XML_TOK_TEXT_CONTOUR_D: | |
| if( bPath ) | |
| sD = rValue; | |
| break; | |
| case XML_TOK_TEXT_CONTOUR_POINTS: | |
| if( !bPath ) | |
| sPoints = rValue; | |
| break; | |
| case XML_TOK_TEXT_CONTOUR_WIDTH: | |
| if( GetImport().GetMM100UnitConverter().convertMeasurePx( nWidth, | |
| rValue) ) | |
| bPixelWidth = sal_True; | |
| else | |
| GetImport().GetMM100UnitConverter().convertMeasure( nWidth, | |
| rValue); | |
| break; | |
| case XML_TOK_TEXT_CONTOUR_HEIGHT: | |
| if( GetImport().GetMM100UnitConverter().convertMeasurePx( nHeight, | |
| rValue) ) | |
| bPixelHeight = sal_True; | |
| else | |
| GetImport().GetMM100UnitConverter().convertMeasure( nHeight, | |
| rValue); | |
| break; | |
| case XML_TOK_TEXT_CONTOUR_AUTO: | |
| bAuto = IsXMLToken(rValue, XML_TRUE); | |
| break; | |
| } | |
| } | |
| OUString sContourPolyPolygon(RTL_CONSTASCII_USTRINGPARAM("ContourPolyPolygon")); | |
| Reference < XPropertySetInfo > xPropSetInfo = rPropSet->getPropertySetInfo(); | |
| if(xPropSetInfo->hasPropertyByName(sContourPolyPolygon) && nWidth > 0 && nHeight > 0 && bPixelWidth == bPixelHeight && (bPath ? sD : sPoints).getLength()) | |
| { | |
| const SdXMLImExViewBox aViewBox( sViewBox, GetImport().GetMM100UnitConverter()); | |
| basegfx::B2DPolyPolygon aPolyPolygon; | |
| Any aAny; | |
| if( bPath ) | |
| { | |
| basegfx::tools::importFromSvgD(aPolyPolygon, sD, true, 0); | |
| } | |
| else | |
| { | |
| basegfx::B2DPolygon aPolygon; | |
| if(basegfx::tools::importFromSvgPoints(aPolygon, sPoints)) | |
| { | |
| aPolyPolygon = basegfx::B2DPolyPolygon(aPolygon); | |
| } | |
| } | |
| if(aPolyPolygon.count()) | |
| { | |
| const basegfx::B2DRange aSourceRange( | |
| aViewBox.GetX(), aViewBox.GetY(), | |
| aViewBox.GetX() + aViewBox.GetWidth(), aViewBox.GetY() + aViewBox.GetHeight()); | |
| const basegfx::B2DRange aTargetRange( | |
| 0.0, 0.0, | |
| nWidth, nHeight); | |
| if(!aSourceRange.equal(aTargetRange)) | |
| { | |
| aPolyPolygon.transform( | |
| basegfx::tools::createSourceRangeTargetRangeTransform( | |
| aSourceRange, | |
| aTargetRange)); | |
| } | |
| com::sun::star::drawing::PointSequenceSequence aPointSequenceSequence; | |
| basegfx::tools::B2DPolyPolygonToUnoPointSequenceSequence(aPolyPolygon, aPointSequenceSequence); | |
| aAny <<= aPointSequenceSequence; | |
| xPropSet->setPropertyValue( sContourPolyPolygon, aAny ); | |
| } | |
| const OUString sIsPixelContour(RTL_CONSTASCII_USTRINGPARAM("IsPixelContour")); | |
| if( xPropSetInfo->hasPropertyByName( sIsPixelContour ) ) | |
| { | |
| aAny.setValue( &bPixelWidth, ::getBooleanCppuType() ); | |
| xPropSet->setPropertyValue( sIsPixelContour, aAny ); | |
| } | |
| const OUString sIsAutomaticContour(RTL_CONSTASCII_USTRINGPARAM("IsAutomaticContour") ); | |
| if( xPropSetInfo->hasPropertyByName( sIsAutomaticContour ) ) | |
| { | |
| aAny.setValue( &bAuto, ::getBooleanCppuType() ); | |
| xPropSet->setPropertyValue( sIsAutomaticContour, aAny ); | |
| } | |
| } | |
| } | |
| XMLTextFrameContourContext_Impl::~XMLTextFrameContourContext_Impl() | |
| { | |
| } | |
| // ------------------------------------------------------------------------ | |
| class XMLTextFrameContext_Impl : public SvXMLImportContext | |
| { | |
| ::com::sun::star::uno::Reference < | |
| ::com::sun::star::text::XTextCursor > xOldTextCursor; | |
| ::com::sun::star::uno::Reference < | |
| ::com::sun::star::beans::XPropertySet > xPropSet; | |
| ::com::sun::star::uno::Reference < | |
| ::com::sun::star::io::XOutputStream > xBase64Stream; | |
| /// old list item and block (#89891#) | |
| bool mbListContextPushed; | |
| const ::rtl::OUString sWidth; | |
| const ::rtl::OUString sWidthType; | |
| const ::rtl::OUString sRelativeWidth; | |
| const ::rtl::OUString sHeight; | |
| const ::rtl::OUString sRelativeHeight; | |
| const ::rtl::OUString sSizeType; | |
| const ::rtl::OUString sIsSyncWidthToHeight; | |
| const ::rtl::OUString sIsSyncHeightToWidth; | |
| const ::rtl::OUString sHoriOrient; | |
| const ::rtl::OUString sHoriOrientPosition; | |
| const ::rtl::OUString sVertOrient; | |
| const ::rtl::OUString sVertOrientPosition; | |
| const ::rtl::OUString sChainNextName; | |
| const ::rtl::OUString sAnchorType; | |
| const ::rtl::OUString sAnchorPageNo; | |
| const ::rtl::OUString sGraphicURL; | |
| const ::rtl::OUString sGraphicFilter; | |
| // --> OD 2009-07-22 #i73249# | |
| // const ::rtl::OUString sAlternativeText; | |
| const ::rtl::OUString sTitle; | |
| const ::rtl::OUString sDescription; | |
| // <-- | |
| const ::rtl::OUString sFrameStyleName; | |
| const ::rtl::OUString sGraphicRotation; | |
| const ::rtl::OUString sTextBoxServiceName; | |
| const ::rtl::OUString sGraphicServiceName; | |
| ::rtl::OUString sName; | |
| ::rtl::OUString sStyleName; | |
| ::rtl::OUString sNextName; | |
| ::rtl::OUString sHRef; | |
| ::rtl::OUString sFilterName; | |
| ::rtl::OUString sCode; | |
| ::rtl::OUString sObject; | |
| ::rtl::OUString sArchive; | |
| ::rtl::OUString sMimeType; | |
| ::rtl::OUString sFrameName; | |
| ::rtl::OUString sAppletName; | |
| ::rtl::OUString sFilterService; | |
| ::rtl::OUString sBase64CharsLeft; | |
| ::rtl::OUString sTblName; | |
| ParamMap aParamMap; | |
| sal_Int32 nX; | |
| sal_Int32 nY; | |
| sal_Int32 nWidth; | |
| sal_Int32 nHeight; | |
| sal_Int32 nZIndex; | |
| sal_Int16 nPage; | |
| sal_Int16 nRotation; | |
| sal_Int16 nRelWidth; | |
| sal_Int16 nRelHeight; | |
| sal_uInt16 nType; | |
| ::com::sun::star::text::TextContentAnchorType eAnchorType; | |
| sal_Bool bMayScript : 1; | |
| sal_Bool bMinWidth : 1; | |
| sal_Bool bMinHeight : 1; | |
| sal_Bool bSyncWidth : 1; | |
| sal_Bool bSyncHeight : 1; | |
| sal_Bool bCreateFailed : 1; | |
| sal_Bool bOwnBase64Stream : 1; | |
| bool mbSetNameForFrame : 1; // #123261# remember if to set the NameForFrame | |
| void Create( sal_Bool bHRefOrBase64 ); | |
| public: | |
| TYPEINFO(); | |
| sal_Bool CreateIfNotThere(); | |
| const OUString& GetHRef() const { return sHRef; } | |
| XMLTextFrameContext_Impl( SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, | |
| const ::rtl::OUString& rLName, | |
| const ::com::sun::star::uno::Reference< | |
| ::com::sun::star::xml::sax::XAttributeList > & rAttrList, | |
| ::com::sun::star::text::TextContentAnchorType eAnchorType, | |
| sal_uInt16 nType, | |
| const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList > & rFrameAttrList, | |
| bool bSetNameForFrame); // #123261# control if to set the NameForFrame | |
| virtual ~XMLTextFrameContext_Impl(); | |
| virtual void EndElement(); | |
| virtual void Characters( const ::rtl::OUString& rChars ); | |
| SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, | |
| const ::rtl::OUString& rLocalName, | |
| const ::com::sun::star::uno::Reference< | |
| ::com::sun::star::xml::sax::XAttributeList > & xAttrList ); | |
| void SetHyperlink( const ::rtl::OUString& rHRef, | |
| const ::rtl::OUString& rName, | |
| const ::rtl::OUString& rTargetFrameName, | |
| sal_Bool bMap ); | |
| // --> OD 2009-07-22 #i73249# | |
| void SetTitle( const ::rtl::OUString& rTitle ); | |
| // <-- | |
| void SetDesc( const ::rtl::OUString& rDesc ); | |
| ::com::sun::star::text::TextContentAnchorType GetAnchorType() const { return eAnchorType; } | |
| const ::com::sun::star::uno::Reference < | |
| ::com::sun::star::beans::XPropertySet >& GetPropSet() const { return xPropSet; } | |
| // #123261# helper to set the NameForFrame | |
| void SetNameForFrameFromPropSet(); | |
| }; | |
| TYPEINIT1( XMLTextFrameContext_Impl, SvXMLImportContext ); | |
| void XMLTextFrameContext_Impl::SetNameForFrameFromPropSet() | |
| { | |
| // set name | |
| UniReference < XMLTextImportHelper > xTextImportHelper = GetImport().GetTextImport(); | |
| Reference < XNamed > xNamed( xPropSet, UNO_QUERY ); | |
| if( xNamed.is() && xTextImportHelper.is() ) | |
| { | |
| OUString sOrigName( xNamed->getName() ); | |
| if( !sOrigName.getLength() || | |
| (sName.getLength() && sOrigName != sName) ) | |
| { | |
| OUString sOldName( sName ); | |
| sal_Int32 i = 0; | |
| while( xTextImportHelper->HasFrameByName( sName ) ) | |
| { | |
| sName = sOldName; | |
| sName += OUString::valueOf( ++i ); | |
| } | |
| xNamed->setName( sName ); | |
| if( sName != sOldName ) | |
| xTextImportHelper->GetRenameMap().Add( XML_TEXT_RENAME_TYPE_FRAME, | |
| sOldName, sName ); | |
| } | |
| } | |
| } | |
| void XMLTextFrameContext_Impl::Create( sal_Bool /*bHRefOrBase64*/ ) | |
| { | |
| UniReference < XMLTextImportHelper > xTextImportHelper = | |
| GetImport().GetTextImport(); | |
| switch ( nType) | |
| { | |
| case XML_TEXT_FRAME_OBJECT: | |
| case XML_TEXT_FRAME_OBJECT_OLE: | |
| if( xBase64Stream.is() ) | |
| { | |
| OUString sURL( GetImport().ResolveEmbeddedObjectURLFromBase64() ); | |
| if( sURL.getLength() ) | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertOLEObject( GetImport(), sURL, | |
| sStyleName, | |
| sTblName, | |
| nWidth, nHeight ); | |
| } | |
| else if( sHRef.getLength() ) | |
| { | |
| OUString sURL( GetImport().ResolveEmbeddedObjectURL( sHRef, | |
| OUString() ) ); | |
| if( GetImport().IsPackageURL( sHRef ) ) | |
| { | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertOLEObject( GetImport(), sURL, | |
| sStyleName, | |
| sTblName, | |
| nWidth, nHeight ); | |
| } | |
| else | |
| { | |
| // it should be an own OOo link that has no storage persistence | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertOOoLink( GetImport(), | |
| sURL, | |
| sStyleName, | |
| sTblName, | |
| nWidth, nHeight ); | |
| } | |
| } | |
| else | |
| { | |
| OUString sURL( RTL_CONSTASCII_USTRINGPARAM("vnd.sun.star.ServiceName:") ); | |
| sURL += sFilterService; | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertOLEObject( GetImport(), sURL, | |
| sStyleName, | |
| sTblName, | |
| nWidth, nHeight ); | |
| } | |
| break; | |
| case XML_TEXT_FRAME_APPLET: | |
| { | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertApplet( sAppletName, sCode, | |
| bMayScript, sHRef, | |
| nWidth, nHeight); | |
| break; | |
| } | |
| case XML_TEXT_FRAME_PLUGIN: | |
| { | |
| if(sHRef.getLength()) | |
| GetImport().GetAbsoluteReference(sHRef); | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertPlugin( sMimeType, sHRef, | |
| nWidth, nHeight); | |
| break; | |
| } | |
| case XML_TEXT_FRAME_FLOATING_FRAME: | |
| { | |
| xPropSet = GetImport().GetTextImport() | |
| ->createAndInsertFloatingFrame( sFrameName, sHRef, | |
| sStyleName, | |
| nWidth, nHeight); | |
| break; | |
| } | |
| default: | |
| { | |
| Reference<XMultiServiceFactory> xFactory( GetImport().GetModel(), | |
| UNO_QUERY ); | |
| if( xFactory.is() ) | |
| { | |
| OUString sServiceName; | |
| switch( nType ) | |
| { | |
| case XML_TEXT_FRAME_TEXTBOX: sServiceName = sTextBoxServiceName; break; | |
| case XML_TEXT_FRAME_GRAPHIC: sServiceName = sGraphicServiceName; break; | |
| } | |
| Reference<XInterface> xIfc = xFactory->createInstance( sServiceName ); | |
| DBG_ASSERT( xIfc.is(), "couldn't create frame" ); | |
| if( xIfc.is() ) | |
| xPropSet = Reference < XPropertySet >( xIfc, UNO_QUERY ); | |
| } | |
| } | |
| } | |
| if( !xPropSet.is() ) | |
| { | |
| bCreateFailed = sal_True; | |
| return; | |
| } | |
| Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo(); | |
| // #123261# set name, but only if wanted, e.g. for MultiImageSupport, it will be set after | |
| // it is decided which image will be used. This is done e.g. to avoid double stuff and effects | |
| // for the target to avoid double names | |
| if(mbSetNameForFrame) | |
| { | |
| SetNameForFrameFromPropSet(); | |
| } | |
| // frame style | |
| XMLPropStyleContext *pStyle = 0; | |
| if( sStyleName.getLength() ) | |
| { | |
| pStyle = xTextImportHelper->FindAutoFrameStyle( sStyleName ); | |
| if( pStyle ) | |
| sStyleName = pStyle->GetParentName(); | |
| } | |
| Any aAny; | |
| if( sStyleName.getLength() ) | |
| { | |
| OUString sDisplayStyleName( GetImport().GetStyleDisplayName( | |
| XML_STYLE_FAMILY_SD_GRAPHICS_ID, sStyleName ) ); | |
| const Reference < XNameContainer > & rStyles = | |
| xTextImportHelper->GetFrameStyles(); | |
| if( rStyles.is() && | |
| rStyles->hasByName( sDisplayStyleName ) ) | |
| { | |
| aAny <<= sDisplayStyleName; | |
| xPropSet->setPropertyValue( sFrameStyleName, aAny ); | |
| } | |
| } | |
| // anchor type (must be set before any other properties, because | |
| // otherwise some orientations cannot be set or will be changed | |
| // afterwards) | |
| aAny <<= eAnchorType; | |
| xPropSet->setPropertyValue( sAnchorType, aAny ); | |
| // hard properties | |
| if( pStyle ) | |
| pStyle->FillPropertySet( xPropSet ); | |
| // x and y | |
| sal_Int16 nHoriOrient = HoriOrientation::NONE; | |
| aAny = xPropSet->getPropertyValue( sHoriOrient ); | |
| aAny >>= nHoriOrient; | |
| if( HoriOrientation::NONE == nHoriOrient ) | |
| { | |
| aAny <<= nX; | |
| xPropSet->setPropertyValue( sHoriOrientPosition, aAny ); | |
| } | |
| sal_Int16 nVertOrient = VertOrientation::NONE; | |
| aAny = xPropSet->getPropertyValue( sVertOrient ); | |
| aAny >>= nVertOrient; | |
| if( VertOrientation::NONE == nVertOrient ) | |
| { | |
| aAny <<= nY; | |
| xPropSet->setPropertyValue( sVertOrientPosition, aAny ); | |
| } | |
| // width | |
| if( nWidth > 0 ) | |
| { | |
| aAny <<= nWidth; | |
| xPropSet->setPropertyValue( sWidth, aAny ); | |
| } | |
| if( nRelWidth > 0 || nWidth > 0 ) | |
| { | |
| aAny <<= nRelWidth; | |
| xPropSet->setPropertyValue( sRelativeWidth, aAny ); | |
| } | |
| if( bSyncWidth || nWidth > 0 ) | |
| { | |
| sal_Bool bTmp = bSyncWidth; | |
| aAny.setValue( &bTmp, ::getBooleanCppuType() ); | |
| xPropSet->setPropertyValue( sIsSyncWidthToHeight, aAny ); | |
| } | |
| if( xPropSetInfo->hasPropertyByName( sWidthType ) && | |
| (bMinWidth || nWidth > 0 || nRelWidth > 0 ) ) | |
| { | |
| sal_Int16 nSizeType = | |
| (bMinWidth && XML_TEXT_FRAME_TEXTBOX == nType) ? SizeType::MIN | |
| : SizeType::FIX; | |
| aAny <<= nSizeType; | |
| xPropSet->setPropertyValue( sWidthType, aAny ); | |
| } | |
| if( nHeight > 0 ) | |
| { | |
| aAny <<= nHeight; | |
| xPropSet->setPropertyValue( sHeight, aAny ); | |
| } | |
| if( nRelHeight > 0 || nHeight > 0 ) | |
| { | |
| aAny <<= nRelHeight; | |
| xPropSet->setPropertyValue( sRelativeHeight, aAny ); | |
| } | |
| if( bSyncHeight || nHeight > 0 ) | |
| { | |
| sal_Bool bTmp = bSyncHeight; | |
| aAny.setValue( &bTmp, ::getBooleanCppuType() ); | |
| xPropSet->setPropertyValue( sIsSyncHeightToWidth, aAny ); | |
| } | |
| if( xPropSetInfo->hasPropertyByName( sSizeType ) && | |
| (bMinHeight || nHeight > 0 || nRelHeight > 0 ) ) | |
| { | |
| sal_Int16 nSizeType = | |
| (bMinHeight && XML_TEXT_FRAME_TEXTBOX == nType) ? SizeType::MIN | |
| : SizeType::FIX; | |
| aAny <<= nSizeType; | |
| xPropSet->setPropertyValue( sSizeType, aAny ); | |
| } | |
| if( XML_TEXT_FRAME_GRAPHIC == nType ) | |
| { | |
| // URL | |
| OSL_ENSURE( sHRef.getLength() > 0 || xBase64Stream.is(), | |
| "neither URL nor base64 image data given" ); | |
| UniReference < XMLTextImportHelper > xTxtImport = | |
| GetImport().GetTextImport(); | |
| if( sHRef.getLength() ) | |
| { | |
| sal_Bool bForceLoad = xTxtImport->IsInsertMode() || | |
| xTxtImport->IsBlockMode() || | |
| xTxtImport->IsStylesOnlyMode() || | |
| xTxtImport->IsOrganizerMode(); | |
| sHRef = GetImport().ResolveGraphicObjectURL( sHRef, !bForceLoad ); | |
| } | |
| else if( xBase64Stream.is() ) | |
| { | |
| sHRef = GetImport().ResolveGraphicObjectURLFromBase64( xBase64Stream ); | |
| xBase64Stream = 0; | |
| } | |
| aAny <<= sHRef; | |
| xPropSet->setPropertyValue( sGraphicURL, aAny ); | |
| // filter name | |
| aAny <<=sFilterName; | |
| xPropSet->setPropertyValue( sGraphicFilter, aAny ); | |
| // rotation | |
| aAny <<= nRotation; | |
| xPropSet->setPropertyValue( sGraphicRotation, aAny ); | |
| } | |
| // page number (must be set after the frame is inserted, because it | |
| // will be overwritten then inserting the frame. | |
| if( TextContentAnchorType_AT_PAGE == eAnchorType && nPage > 0 ) | |
| { | |
| aAny <<= nPage; | |
| xPropSet->setPropertyValue( sAnchorPageNo, aAny ); | |
| } | |
| if( XML_TEXT_FRAME_OBJECT != nType && | |
| XML_TEXT_FRAME_OBJECT_OLE != nType && | |
| XML_TEXT_FRAME_APPLET != nType && | |
| XML_TEXT_FRAME_PLUGIN!= nType && | |
| XML_TEXT_FRAME_FLOATING_FRAME != nType) | |
| { | |
| Reference < XTextContent > xTxtCntnt( xPropSet, UNO_QUERY ); | |
| xTextImportHelper->InsertTextContent( xTxtCntnt ); | |
| } | |
| // #107848# | |
| // Make adding the shepe to Z-Ordering dependent from if we are | |
| // inside a inside_deleted_section (redlining). That is necessary | |
| // since the shape will be removed again later. It would lead to | |
| // errors if it would stay inside the Z-Ordering. Thus, the | |
| // easiest way to solve that conflict is to not add it here. | |
| if(!GetImport().HasTextImport() | |
| || !GetImport().GetTextImport()->IsInsideDeleteContext()) | |
| { | |
| Reference < XShape > xShape( xPropSet, UNO_QUERY ); | |
| GetImport().GetShapeImport()->shapeWithZIndexAdded( xShape, nZIndex ); | |
| } | |
| if( XML_TEXT_FRAME_TEXTBOX == nType ) | |
| { | |
| xTextImportHelper->ConnectFrameChains( sName, sNextName, xPropSet ); | |
| Reference < XTextFrame > xTxtFrame( xPropSet, UNO_QUERY ); | |
| Reference < XText > xTxt = xTxtFrame->getText(); | |
| xOldTextCursor = xTextImportHelper->GetCursor(); | |
| xTextImportHelper->SetCursor( xTxt->createTextCursor() ); | |
| // remember old list item and block (#89892#) and reset them | |
| // for the text frame | |
| xTextImportHelper->PushListContext(); | |
| mbListContextPushed = true; | |
| } | |
| } | |
| sal_Bool XMLTextFrameContext_Impl::CreateIfNotThere() | |
| { | |
| if( !xPropSet.is() && | |
| ( XML_TEXT_FRAME_OBJECT_OLE == nType || | |
| XML_TEXT_FRAME_GRAPHIC == nType ) && | |
| xBase64Stream.is() && !bCreateFailed ) | |
| { | |
| if( bOwnBase64Stream ) | |
| xBase64Stream->closeOutput(); | |
| Create( sal_True ); | |
| } | |
| return xPropSet.is(); | |
| } | |
| XMLTextFrameContext_Impl::XMLTextFrameContext_Impl( | |
| SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, const OUString& rLName, | |
| const Reference< XAttributeList > & rAttrList, | |
| TextContentAnchorType eATyp, | |
| sal_uInt16 nNewType, | |
| const Reference< XAttributeList > & rFrameAttrList, | |
| bool bSetNameForFrame) | |
| : SvXMLImportContext( rImport, nPrfx, rLName ) | |
| , mbListContextPushed( false ) | |
| , sWidth(RTL_CONSTASCII_USTRINGPARAM("Width")) | |
| , sWidthType(RTL_CONSTASCII_USTRINGPARAM("WidthType")) | |
| , sRelativeWidth(RTL_CONSTASCII_USTRINGPARAM("RelativeWidth")) | |
| , sHeight(RTL_CONSTASCII_USTRINGPARAM("Height")) | |
| , sRelativeHeight(RTL_CONSTASCII_USTRINGPARAM("RelativeHeight")) | |
| , sSizeType(RTL_CONSTASCII_USTRINGPARAM("SizeType")) | |
| , sIsSyncWidthToHeight(RTL_CONSTASCII_USTRINGPARAM("IsSyncWidthToHeight")) | |
| , sIsSyncHeightToWidth(RTL_CONSTASCII_USTRINGPARAM("IsSyncHeightToWidth")) | |
| , sHoriOrient(RTL_CONSTASCII_USTRINGPARAM("HoriOrient")) | |
| , sHoriOrientPosition(RTL_CONSTASCII_USTRINGPARAM("HoriOrientPosition")) | |
| , sVertOrient(RTL_CONSTASCII_USTRINGPARAM("VertOrient")) | |
| , sVertOrientPosition(RTL_CONSTASCII_USTRINGPARAM("VertOrientPosition")) | |
| , sChainNextName(RTL_CONSTASCII_USTRINGPARAM("ChainNextName")) | |
| , sAnchorType(RTL_CONSTASCII_USTRINGPARAM("AnchorType")) | |
| , sAnchorPageNo(RTL_CONSTASCII_USTRINGPARAM("AnchorPageNo")) | |
| , sGraphicURL(RTL_CONSTASCII_USTRINGPARAM("GraphicURL")) | |
| , sGraphicFilter(RTL_CONSTASCII_USTRINGPARAM("GraphicFilter")) | |
| // --> OD 2009-07-22 #i73249# | |
| //, sAlternativeText(RTL_CONSTASCII_USTRINGPARAM("AlternativeText")) | |
| , sTitle(RTL_CONSTASCII_USTRINGPARAM("Title")) | |
| , sDescription(RTL_CONSTASCII_USTRINGPARAM("Description")) | |
| // <-- | |
| , sFrameStyleName(RTL_CONSTASCII_USTRINGPARAM("FrameStyleName")) | |
| , sGraphicRotation(RTL_CONSTASCII_USTRINGPARAM("GraphicRotation")) | |
| , sTextBoxServiceName(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextFrame")) | |
| , sGraphicServiceName(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.GraphicObject")) | |
| , nType( nNewType ) | |
| , eAnchorType( eATyp ) | |
| , mbSetNameForFrame(bSetNameForFrame) | |
| { | |
| nX = 0; | |
| nY = 0; | |
| nWidth = 0; | |
| nHeight = 0; | |
| nZIndex = -1; | |
| nPage = 0; | |
| nRotation = 0; | |
| nRelWidth = 0; | |
| nRelHeight = 0; | |
| bMayScript = sal_False; | |
| bMinHeight = sal_False; | |
| bMinWidth = sal_False; | |
| bSyncWidth = sal_False; | |
| bSyncHeight = sal_False; | |
| bCreateFailed = sal_False; | |
| bOwnBase64Stream = sal_False; | |
| UniReference < XMLTextImportHelper > xTxtImport = | |
| GetImport().GetTextImport(); | |
| const SvXMLTokenMap& rTokenMap = | |
| xTxtImport->GetTextFrameAttrTokenMap(); | |
| sal_Int16 nAttrCount = rAttrList.is() ? rAttrList->getLength() : 0; | |
| sal_Int16 nTotalAttrCount = nAttrCount + (rFrameAttrList.is() ? rFrameAttrList->getLength() : 0); | |
| for( sal_Int16 i=0; i < nTotalAttrCount; i++ ) | |
| { | |
| const OUString& rAttrName = | |
| i < nAttrCount ? rAttrList->getNameByIndex( i ) : rFrameAttrList->getNameByIndex( i-nAttrCount ); | |
| const OUString& rValue = | |
| i < nAttrCount ? rAttrList->getValueByIndex( i ): rFrameAttrList->getValueByIndex( i-nAttrCount ); | |
| OUString aLocalName; | |
| sal_uInt16 nPrefix = | |
| GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, | |
| &aLocalName ); | |
| switch( rTokenMap.Get( nPrefix, aLocalName ) ) | |
| { | |
| case XML_TOK_TEXT_FRAME_STYLE_NAME: | |
| sStyleName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_NAME: | |
| sName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_FRAME_NAME: | |
| sFrameName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_APPLET_NAME: | |
| sAppletName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_ANCHOR_TYPE: | |
| if( TextContentAnchorType_AT_PARAGRAPH == eAnchorType || | |
| TextContentAnchorType_AT_CHARACTER == eAnchorType || | |
| TextContentAnchorType_AS_CHARACTER == eAnchorType ) | |
| { | |
| TextContentAnchorType eNew; | |
| if( XMLAnchorTypePropHdl::convert( rValue, eNew ) && | |
| ( TextContentAnchorType_AT_PARAGRAPH == eNew || | |
| TextContentAnchorType_AT_CHARACTER == eNew || | |
| TextContentAnchorType_AS_CHARACTER == eNew || | |
| TextContentAnchorType_AT_PAGE == eNew) ) | |
| eAnchorType = eNew; | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_ANCHOR_PAGE_NUMBER: | |
| { | |
| sal_Int32 nTmp; | |
| if( GetImport().GetMM100UnitConverter(). | |
| convertNumber( nTmp, rValue, 1, SHRT_MAX ) ) | |
| nPage = (sal_Int16)nTmp; | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_X: | |
| GetImport().GetMM100UnitConverter().convertMeasure( nX, rValue ); | |
| break; | |
| case XML_TOK_TEXT_FRAME_Y: | |
| GetImport().GetMM100UnitConverter().convertMeasure( nY, rValue ); | |
| break; | |
| case XML_TOK_TEXT_FRAME_WIDTH: | |
| // relative widths are obsolete since SRC617. Remove them some day! | |
| if( rValue.indexOf( '%' ) != -1 ) | |
| { | |
| sal_Int32 nTmp; | |
| GetImport().GetMM100UnitConverter().convertPercent( nTmp, | |
| rValue ); | |
| nRelWidth = (sal_Int16)nTmp; | |
| } | |
| else | |
| { | |
| GetImport().GetMM100UnitConverter().convertMeasure( nWidth, | |
| rValue, 0 ); | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_REL_WIDTH: | |
| if( IsXMLToken(rValue, XML_SCALE) ) | |
| { | |
| bSyncWidth = sal_True; | |
| } | |
| else | |
| { | |
| sal_Int32 nTmp; | |
| if( GetImport().GetMM100UnitConverter(). | |
| convertPercent( nTmp, rValue ) ) | |
| nRelWidth = (sal_Int16)nTmp; | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_MIN_WIDTH: | |
| if( rValue.indexOf( '%' ) != -1 ) | |
| { | |
| sal_Int32 nTmp; | |
| GetImport().GetMM100UnitConverter().convertPercent( nTmp, | |
| rValue ); | |
| nRelWidth = (sal_Int16)nTmp; | |
| } | |
| else | |
| { | |
| GetImport().GetMM100UnitConverter().convertMeasure( nWidth, | |
| rValue, 0 ); | |
| } | |
| bMinWidth = sal_True; | |
| break; | |
| case XML_TOK_TEXT_FRAME_HEIGHT: | |
| // relative heights are obsolete since SRC617. Remove them some day! | |
| if( rValue.indexOf( '%' ) != -1 ) | |
| { | |
| sal_Int32 nTmp; | |
| GetImport().GetMM100UnitConverter().convertPercent( nTmp, | |
| rValue ); | |
| nRelHeight = (sal_Int16)nTmp; | |
| } | |
| else | |
| { | |
| GetImport().GetMM100UnitConverter().convertMeasure( nHeight, | |
| rValue, 0 ); | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_REL_HEIGHT: | |
| if( IsXMLToken( rValue, XML_SCALE ) ) | |
| { | |
| bSyncHeight = sal_True; | |
| } | |
| else if( IsXMLToken( rValue, XML_SCALE_MIN ) ) | |
| { | |
| bSyncHeight = sal_True; | |
| bMinHeight = sal_True; | |
| } | |
| else | |
| { | |
| sal_Int32 nTmp; | |
| if( GetImport().GetMM100UnitConverter(). | |
| convertPercent( nTmp, rValue ) ) | |
| nRelHeight = (sal_Int16)nTmp; | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_MIN_HEIGHT: | |
| if( rValue.indexOf( '%' ) != -1 ) | |
| { | |
| sal_Int32 nTmp; | |
| GetImport().GetMM100UnitConverter().convertPercent( nTmp, | |
| rValue ); | |
| nRelHeight = (sal_Int16)nTmp; | |
| } | |
| else | |
| { | |
| GetImport().GetMM100UnitConverter().convertMeasure( nHeight, | |
| rValue, 0 ); | |
| } | |
| bMinHeight = sal_True; | |
| break; | |
| case XML_TOK_TEXT_FRAME_Z_INDEX: | |
| GetImport().GetMM100UnitConverter().convertNumber( nZIndex, rValue, -1 ); | |
| break; | |
| case XML_TOK_TEXT_FRAME_NEXT_CHAIN_NAME: | |
| sNextName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_HREF: | |
| sHRef = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_FILTER_NAME: | |
| sFilterName = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_TRANSFORM: | |
| { | |
| OUString sValue( rValue ); | |
| sValue.trim(); | |
| const OUString aRotate(GetXMLToken(XML_ROTATE)); | |
| const sal_Int32 nRotateLen(aRotate.getLength()); | |
| sal_Int32 nLen = sValue.getLength(); | |
| if( XML_NAMESPACE_DRAW == nPrefix ) | |
| { | |
| // "translate (..) rotate (radians) translate (..)", only the angle is used | |
| const sal_Int32 nPos = sValue.indexOf( aRotate ); | |
| const sal_Int32 nOpen = nPos < 0 ? -1 : sValue.indexOf( (sal_Unicode)'(', nPos ); | |
| const sal_Int32 nClose = nOpen < 0 ? -1 : sValue.indexOf( (sal_Unicode)')', nOpen ); | |
| double fRad = 0.0; | |
| if( nClose > 0 && SvXMLUnitConverter::convertDouble( fRad, | |
| sValue.copy( nOpen+1, nClose-nOpen-1 ).trim() ) ) | |
| { | |
| const sal_Int32 nTenths = basegfx::fround( fmod( basegfx::rad2deg( fRad ), 360.0 ) * 10.0 ); | |
| nRotation = (sal_Int16)( ( nTenths + 3600 ) % 3600 ); | |
| } | |
| } | |
| else if( nLen >= nRotateLen+3 && | |
| 0 == sValue.compareTo( aRotate, nRotateLen ) && | |
| '(' == sValue[nRotateLen] && | |
| ')' == sValue[nLen-1] ) | |
| { | |
| sValue = sValue.copy( nRotateLen+1, nLen-(nRotateLen+2) ); | |
| sValue.trim(); | |
| sal_Int32 nVal; | |
| if( GetImport().GetMM100UnitConverter().convertNumber( nVal, sValue ) ) | |
| nRotation = (sal_Int16)(nVal % 3600 ); | |
| } | |
| } | |
| break; | |
| case XML_TOK_TEXT_FRAME_CODE: | |
| sCode = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_OBJECT: | |
| sObject = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_ARCHIVE: | |
| sArchive = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_MAY_SCRIPT: | |
| bMayScript = IsXMLToken( rValue, XML_TRUE ); | |
| break; | |
| case XML_TOK_TEXT_FRAME_MIME_TYPE: | |
| sMimeType = rValue; | |
| break; | |
| case XML_TOK_TEXT_FRAME_NOTIFY_ON_UPDATE: | |
| sTblName = rValue; | |
| break; | |
| } | |
| } | |
| if( ( (XML_TEXT_FRAME_GRAPHIC == nType || | |
| XML_TEXT_FRAME_OBJECT == nType || | |
| XML_TEXT_FRAME_OBJECT_OLE == nType) && | |
| !sHRef.getLength() ) || | |
| ( XML_TEXT_FRAME_APPLET == nType && !sCode.getLength() ) || | |
| ( XML_TEXT_FRAME_PLUGIN == nType && | |
| sHRef.getLength() == 0 && sMimeType.getLength() == 0 ) ) | |
| return; // no URL: no image or OLE object | |
| Create( sal_True ); | |
| } | |
| XMLTextFrameContext_Impl::~XMLTextFrameContext_Impl() | |
| { | |
| } | |
| void XMLTextFrameContext_Impl::EndElement() | |
| { | |
| CreateIfNotThere(); | |
| if( xOldTextCursor.is() ) | |
| { | |
| GetImport().GetTextImport()->DeleteParagraph(); | |
| GetImport().GetTextImport()->SetCursor( xOldTextCursor ); | |
| } | |
| // reinstall old list item (if necessary) #89892# | |
| if (mbListContextPushed) { | |
| GetImport().GetTextImport()->PopListContext(); | |
| } | |
| if (( nType == XML_TEXT_FRAME_APPLET || nType == XML_TEXT_FRAME_PLUGIN ) && xPropSet.is()) | |
| GetImport().GetTextImport()->endAppletOrPlugin( xPropSet, aParamMap); | |
| } | |
| SvXMLImportContext *XMLTextFrameContext_Impl::CreateChildContext( | |
| sal_uInt16 nPrefix, | |
| const OUString& rLocalName, | |
| const Reference< XAttributeList > & xAttrList ) | |
| { | |
| SvXMLImportContext *pContext = 0; | |
| if( XML_NAMESPACE_DRAW == nPrefix ) | |
| { | |
| if ( (nType == XML_TEXT_FRAME_APPLET || nType == XML_TEXT_FRAME_PLUGIN) && | |
| IsXMLToken( rLocalName, XML_PARAM ) ) | |
| { | |
| pContext = new XMLTextFrameParam_Impl( GetImport(), | |
| nPrefix, rLocalName, | |
| xAttrList, nType, aParamMap ); | |
| } | |
| } | |
| else if( (XML_NAMESPACE_OFFICE == nPrefix) ) | |
| { | |
| if( IsXMLToken( rLocalName, XML_BINARY_DATA ) ) | |
| { | |
| if( !xPropSet.is() && !xBase64Stream.is() && !bCreateFailed ) | |
| { | |
| switch( nType ) | |
| { | |
| case XML_TEXT_FRAME_GRAPHIC: | |
| xBase64Stream = | |
| GetImport().GetStreamForGraphicObjectURLFromBase64(); | |
| break; | |
| case XML_TEXT_FRAME_OBJECT_OLE: | |
| xBase64Stream = | |
| GetImport().GetStreamForEmbeddedObjectURLFromBase64(); | |
| break; | |
| } | |
| if( xBase64Stream.is() ) | |
| pContext = new XMLBase64ImportContext( GetImport(), nPrefix, | |
| rLocalName, xAttrList, | |
| xBase64Stream ); | |
| } | |
| } | |
| } | |
| // --> OD 2009-08-17 #i100480# | |
| // correction of condition which also avoids warnings. | |
| if( !pContext && | |
| ( XML_TEXT_FRAME_OBJECT == nType && | |
| ( ( XML_NAMESPACE_OFFICE == nPrefix && | |
| IsXMLToken( rLocalName, XML_DOCUMENT ) ) || | |
| ( XML_NAMESPACE_MATH == nPrefix && | |
| IsXMLToken( rLocalName, XML_MATH ) ) ) ) ) | |
| // <-- | |
| { | |
| if( !xPropSet.is() && !bCreateFailed ) | |
| { | |
| XMLEmbeddedObjectImportContext *pEContext = | |
| new XMLEmbeddedObjectImportContext( GetImport(), nPrefix, | |
| rLocalName, xAttrList ); | |
| sFilterService = pEContext->GetFilterServiceName(); | |
| if( sFilterService.getLength() != 0 ) | |
| { | |
| Create( sal_False ); | |
| if( xPropSet.is() ) | |
| { | |
| Reference < XEmbeddedObjectSupplier > xEOS( xPropSet, | |
| UNO_QUERY ); | |
| OSL_ENSURE( xEOS.is(), | |
| "no embedded object supplier for own object" ); | |
| Reference<com::sun::star::lang::XComponent> aXComponent(xEOS->getEmbeddedObject()); | |
| pEContext->SetComponent( aXComponent ); | |
| } | |
| } | |
| pContext = pEContext; | |
| } | |
| } | |
| if( !pContext && xOldTextCursor.is() ) // text-box | |
| pContext = GetImport().GetTextImport()->CreateTextChildContext( | |
| GetImport(), nPrefix, rLocalName, xAttrList, | |
| XML_TEXT_TYPE_TEXTBOX ); | |
| if( !pContext ) | |
| pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName ); | |
| return pContext; | |
| } | |
| void XMLTextFrameContext_Impl::Characters( const OUString& rChars ) | |
| { | |
| if( ( XML_TEXT_FRAME_OBJECT_OLE == nType || | |
| XML_TEXT_FRAME_GRAPHIC == nType) && | |
| !xPropSet.is() && !bCreateFailed ) | |
| { | |
| OUString sTrimmedChars( rChars. trim() ); | |
| if( sTrimmedChars.getLength() ) | |
| { | |
| if( !xBase64Stream.is() ) | |
| { | |
| if( XML_TEXT_FRAME_GRAPHIC == nType ) | |
| { | |
| xBase64Stream = | |
| GetImport().GetStreamForGraphicObjectURLFromBase64(); | |
| } | |
| else | |
| { | |
| xBase64Stream = | |
| GetImport().GetStreamForEmbeddedObjectURLFromBase64(); | |
| } | |
| if( xBase64Stream.is() ) | |
| bOwnBase64Stream = sal_True; | |
| } | |
| if( bOwnBase64Stream && xBase64Stream.is() ) | |
| { | |
| OUString sChars; | |
| if( !sBase64CharsLeft.isEmpty() ) | |
| { | |
| sChars = sBase64CharsLeft; | |
| sChars += sTrimmedChars; | |
| sBase64CharsLeft = OUString(); | |
| } | |
| else | |
| { | |
| sChars = sTrimmedChars; | |
| } | |
| Sequence< sal_Int8 > aBuffer( (sChars.getLength() / 4) * 3 ); | |
| sal_Int32 nCharsDecoded = | |
| GetImport().GetMM100UnitConverter(). | |
| decodeBase64SomeChars( aBuffer, sChars ); | |
| xBase64Stream->writeBytes( aBuffer ); | |
| if( nCharsDecoded != sChars.getLength() ) | |
| sBase64CharsLeft = sChars.copy( nCharsDecoded ); | |
| } | |
| } | |
| } | |
| } | |
| void XMLTextFrameContext_Impl::SetHyperlink( const OUString& rHRef, | |
| const OUString& rName, | |
| const OUString& rTargetFrameName, | |
| sal_Bool bMap ) | |
| { | |
| static ::rtl::OUString s_HyperLinkURL( | |
| RTL_CONSTASCII_USTRINGPARAM("HyperLinkURL")); | |
| static ::rtl::OUString s_HyperLinkName( | |
| RTL_CONSTASCII_USTRINGPARAM("HyperLinkName")); | |
| static ::rtl::OUString s_HyperLinkTarget( | |
| RTL_CONSTASCII_USTRINGPARAM("HyperLinkTarget")); | |
| static ::rtl::OUString s_ServerMap( | |
| RTL_CONSTASCII_USTRINGPARAM("ServerMap")); | |
| if( !xPropSet.is() ) | |
| return; | |
| UniReference< XMLTextImportHelper > xTxtImp = GetImport().GetTextImport(); | |
| Reference < XPropertySetInfo > xPropSetInfo = | |
| xPropSet->getPropertySetInfo(); | |
| if( !xPropSetInfo.is() || | |
| !xPropSetInfo->hasPropertyByName(s_HyperLinkURL)) | |
| return; | |
| Any aAny; | |
| aAny <<= rHRef; | |
| xPropSet->setPropertyValue( s_HyperLinkURL, aAny ); | |
| if (xPropSetInfo->hasPropertyByName(s_HyperLinkName)) | |
| { | |
| aAny <<= rName; | |
| xPropSet->setPropertyValue(s_HyperLinkName, aAny); | |
| } | |
| if (xPropSetInfo->hasPropertyByName(s_HyperLinkTarget)) | |
| { | |
| aAny <<= rTargetFrameName; | |
| xPropSet->setPropertyValue( s_HyperLinkTarget, aAny ); | |
| } | |
| if (xPropSetInfo->hasPropertyByName(s_ServerMap)) | |
| { | |
| aAny.setValue( &bMap, ::getBooleanCppuType() ); | |
| xPropSet->setPropertyValue(s_ServerMap, aAny); | |
| } | |
| } | |
| // --> OD 2009-07-22 #i73249# | |
| void XMLTextFrameContext_Impl::SetTitle( const OUString& rTitle ) | |
| { | |
| if ( xPropSet.is() ) | |
| { | |
| Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo(); | |
| if( xPropSetInfo->hasPropertyByName( sTitle ) ) | |
| { | |
| xPropSet->setPropertyValue( sTitle, makeAny( rTitle ) ); | |
| } | |
| } | |
| } | |
| void XMLTextFrameContext_Impl::SetDesc( const OUString& rDesc ) | |
| { | |
| if ( xPropSet.is() ) | |
| { | |
| Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo(); | |
| if( xPropSetInfo->hasPropertyByName( sDescription ) ) | |
| { | |
| xPropSet->setPropertyValue( sDescription, makeAny( rDesc ) ); | |
| } | |
| } | |
| } | |
| // <-- | |
| //----------------------------------------------------------------------------------------------------- | |
| TYPEINIT1( XMLTextFrameContext, SvXMLImportContext ); | |
| void XMLTextFrameContext::removeGraphicFromImportContext(const SvXMLImportContext& rContext) const | |
| { | |
| const XMLTextFrameContext_Impl* pXMLTextFrameContext_Impl = dynamic_cast< const XMLTextFrameContext_Impl* >(&rContext); | |
| if(pXMLTextFrameContext_Impl) | |
| { | |
| try | |
| { | |
| // just dispose to delete | |
| uno::Reference< lang::XComponent > xComp(pXMLTextFrameContext_Impl->GetPropSet(), UNO_QUERY); | |
| if(xComp.is()) | |
| { | |
| xComp->dispose(); | |
| } | |
| } | |
| catch( uno::Exception& ) | |
| { | |
| DBG_ERROR( "Error in cleanup of multiple graphic object import (!)" ); | |
| } | |
| } | |
| } | |
| rtl::OUString XMLTextFrameContext::getGraphicURLFromImportContext(const SvXMLImportContext& rContext) const | |
| { | |
| rtl::OUString aRetval; | |
| const XMLTextFrameContext_Impl* pXMLTextFrameContext_Impl = dynamic_cast< const XMLTextFrameContext_Impl* >(&rContext); | |
| if(pXMLTextFrameContext_Impl) | |
| { | |
| return pXMLTextFrameContext_Impl->GetHRef(); | |
| } | |
| return aRetval; | |
| } | |
| sal_Bool XMLTextFrameContext::CreateIfNotThere() | |
| { | |
| sal_Bool bRet = sal_False; | |
| SvXMLImportContext *pContext = &m_xImplContext; | |
| XMLTextFrameContext_Impl *pImpl = PTR_CAST( XMLTextFrameContext_Impl, pContext ); | |
| if( pImpl ) | |
| bRet = pImpl->CreateIfNotThere(); | |
| return bRet; | |
| } | |
| sal_Bool XMLTextFrameContext::CreateIfNotThere( ::com::sun::star::uno::Reference < | |
| ::com::sun::star::beans::XPropertySet >& rPropSet ) | |
| { | |
| SvXMLImportContext *pContext = &m_xImplContext; | |
| XMLTextFrameContext_Impl *pImpl = PTR_CAST( XMLTextFrameContext_Impl, pContext ); | |
| if( pImpl ) | |
| { | |
| if( pImpl->CreateIfNotThere() ) | |
| rPropSet = pImpl->GetPropSet(); | |
| } | |
| return rPropSet.is(); | |
| } | |
| XMLTextFrameContext::XMLTextFrameContext( | |
| SvXMLImport& rImport, | |
| sal_uInt16 nPrfx, const OUString& rLName, | |
| const Reference< XAttributeList > & xAttrList, | |
| TextContentAnchorType eATyp ) | |
| : SvXMLImportContext( rImport, nPrfx, rLName ) | |
| , multiImageImportHelper() | |
| , m_xAttrList( new SvXMLAttributeList( xAttrList ) ) | |
| , m_pHyperlink( 0 ) | |
| // --> OD 2009-07-22 #i73249# | |
| , m_sTitle() | |
| , m_sDesc() | |
| // <-- | |
| , m_eDefaultAnchorType( eATyp ) | |
| // --> OD 2006-03-10 #i51726# | |
| , m_HasAutomaticStyleWithoutParentStyle( sal_False ) | |
| // <-- | |
| , m_bSupportsReplacement( sal_False ) | |
| { | |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; | |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) | |
| { | |
| const OUString& rAttrName = xAttrList->getNameByIndex( i ); | |
| OUString aLocalName; | |
| sal_uInt16 nPrefix = | |
| GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName ); | |
| // --> OD 2006-03-10 #i51726# | |
| // New distinguish attribute between Writer objects and Draw objects is: | |
| // Draw objects have an automatic style without a parent style | |
| if ( XML_NAMESPACE_DRAW == nPrefix && | |
| IsXMLToken( aLocalName, XML_STYLE_NAME ) ) | |
| { | |
| OUString aStyleName = xAttrList->getValueByIndex( i ); | |
| if( aStyleName.getLength() ) | |
| { | |
| UniReference < XMLTextImportHelper > xTxtImport = | |
| GetImport().GetTextImport(); | |
| XMLPropStyleContext* pStyle( 0L ); | |
| pStyle = xTxtImport->FindAutoFrameStyle( aStyleName ); | |
| if ( pStyle && !pStyle->GetParentName().getLength() ) | |
| { | |
| m_HasAutomaticStyleWithoutParentStyle = sal_True; | |
| } | |
| } | |
| } | |
| // <-- | |
| else if ( XML_NAMESPACE_TEXT == nPrefix && | |
| IsXMLToken( aLocalName, XML_ANCHOR_TYPE ) ) | |
| { | |
| TextContentAnchorType eNew; | |
| if( XMLAnchorTypePropHdl::convert( xAttrList->getValueByIndex(i), | |
| eNew ) && | |
| ( TextContentAnchorType_AT_PARAGRAPH == eNew || | |
| TextContentAnchorType_AT_CHARACTER == eNew || | |
| TextContentAnchorType_AS_CHARACTER == eNew || | |
| TextContentAnchorType_AT_PAGE == eNew) ) | |
| m_eDefaultAnchorType = eNew; | |
| } | |
| } | |
| } | |
| XMLTextFrameContext::~XMLTextFrameContext() | |
| { | |
| delete m_pHyperlink; | |
| } | |
| void XMLTextFrameContext::EndElement() | |
| { | |
| /// solve if multiple image child contexts were imported | |
| /// the winner is returned, if something has yet to be done with it | |
| SvXMLImportContext* pWinner = const_cast< SvXMLImportContext* >( solveMultipleImages() ); | |
| // #123261# see if the winner is a XMLTextFrameContext_Impl | |
| XMLTextFrameContext_Impl* pImplWinner = dynamic_cast< XMLTextFrameContext_Impl* >(pWinner); | |
| if(pImplWinner) | |
| { | |
| // #123261# if yes, set name now, after the winner is identified (setting at each | |
| // candidate may run into problems due to colliding with efforts in the target to | |
| // avoid double names, so only set one name at one image and not at each) | |
| pImplWinner->SetNameForFrameFromPropSet(); | |
| } | |
| SvXMLImportContext *pContext = &m_xImplContext; | |
| XMLTextFrameContext_Impl *pImpl = dynamic_cast< XMLTextFrameContext_Impl* >(pContext); | |
| if( pImpl ) | |
| { | |
| pImpl->CreateIfNotThere(); | |
| } | |
| // --> OD 2009-07-22 #i73249# | |
| // // alternative text | |
| // if( m_sDesc.getLength() ) | |
| // pImpl->SetDesc( m_sDesc ); | |
| // Bug #126768: set all properties to the winner | |
| if ( pImplWinner ) { | |
| pImpl = pImplWinner; | |
| } | |
| if ( pImpl ) { | |
| // svg:title | |
| if( m_sTitle.getLength() ) | |
| { | |
| pImpl->SetTitle( m_sTitle ); | |
| } | |
| if( m_sDesc.getLength() ) | |
| { | |
| pImpl->SetDesc( m_sDesc ); | |
| } | |
| // <-- | |
| if( m_pHyperlink ) | |
| { | |
| pImpl->SetHyperlink( m_pHyperlink->GetHRef(), m_pHyperlink->GetName(), | |
| m_pHyperlink->GetTargetFrameName(), m_pHyperlink->GetMap() ); | |
| delete m_pHyperlink; | |
| m_pHyperlink = 0; | |
| } | |
| } | |
| } | |
| SvXMLImportContext *XMLTextFrameContext::CreateChildContext( | |
| sal_uInt16 p_nPrefix, | |
| const OUString& rLocalName, | |
| const Reference< XAttributeList > & xAttrList ) | |
| { | |
| SvXMLImportContext *pContext = 0; | |
| if( !m_xImplContext.Is() ) | |
| { | |
| // no child exists | |
| if( XML_NAMESPACE_DRAW == p_nPrefix ) | |
| { | |
| sal_uInt16 nFrameType = USHRT_MAX; | |
| if( IsXMLToken( rLocalName, XML_TEXT_BOX ) ) | |
| nFrameType = XML_TEXT_FRAME_TEXTBOX; | |
| else if( IsXMLToken( rLocalName, XML_IMAGE ) ) | |
| nFrameType = XML_TEXT_FRAME_GRAPHIC; | |
| else if( IsXMLToken( rLocalName, XML_OBJECT ) ) | |
| nFrameType = XML_TEXT_FRAME_OBJECT; | |
| else if( IsXMLToken( rLocalName, XML_OBJECT_OLE ) ) | |
| nFrameType = XML_TEXT_FRAME_OBJECT_OLE; | |
| else if( IsXMLToken( rLocalName, XML_APPLET) ) | |
| nFrameType = XML_TEXT_FRAME_APPLET; | |
| else if( IsXMLToken( rLocalName, XML_PLUGIN ) ) | |
| nFrameType = XML_TEXT_FRAME_PLUGIN; | |
| else if( IsXMLToken( rLocalName, XML_FLOATING_FRAME ) ) | |
| nFrameType = XML_TEXT_FRAME_FLOATING_FRAME; | |
| if( USHRT_MAX != nFrameType ) | |
| { | |
| // --> OD 2006-03-10 #i51726# | |
| if ( ( XML_TEXT_FRAME_TEXTBOX == nFrameType || | |
| XML_TEXT_FRAME_GRAPHIC == nFrameType ) && | |
| m_HasAutomaticStyleWithoutParentStyle ) | |
| // <-- | |
| { | |
| Reference < XShapes > xShapes; | |
| pContext = GetImport().GetShapeImport()->CreateFrameChildContext( | |
| GetImport(), p_nPrefix, rLocalName, xAttrList, xShapes, m_xAttrList ); | |
| } | |
| else if( XML_TEXT_FRAME_PLUGIN == nFrameType ) | |
| { | |
| bool bMedia = false; | |
| // check, if we have a media object | |
| for( sal_Int16 n = 0, nAttrCount = ( xAttrList.is() ? xAttrList->getLength() : 0 ); n < nAttrCount; ++n ) | |
| { | |
| OUString aLocalName; | |
| sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( n ), &aLocalName ); | |
| if( nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( aLocalName, XML_MIME_TYPE ) ) | |
| { | |
| if( 0 == xAttrList->getValueByIndex( n ).compareToAscii( "application/vnd.sun.star.media" ) ) | |
| bMedia = true; | |
| // leave this loop | |
| n = nAttrCount - 1; | |
| } | |
| } | |
| if( bMedia ) | |
| { | |
| Reference < XShapes > xShapes; | |
| pContext = GetImport().GetShapeImport()->CreateFrameChildContext( | |
| GetImport(), p_nPrefix, rLocalName, xAttrList, xShapes, m_xAttrList ); | |
| } | |
| } | |
| else if( XML_TEXT_FRAME_OBJECT == nFrameType || | |
| XML_TEXT_FRAME_OBJECT_OLE == nFrameType ) | |
| { | |
| m_bSupportsReplacement = sal_True; | |
| } | |
| else if(XML_TEXT_FRAME_GRAPHIC == nFrameType) | |
| { | |
| setSupportsMultipleContents(IsXMLToken(rLocalName, XML_IMAGE)); | |
| } | |
| if( !pContext ) | |
| { | |
| pContext = new XMLTextFrameContext_Impl( | |
| GetImport(), | |
| p_nPrefix, | |
| rLocalName, | |
| xAttrList, | |
| m_eDefaultAnchorType, | |
| nFrameType, | |
| m_xAttrList, | |
| !getSupportsMultipleContents()); | |
| } | |
| m_xImplContext = pContext; | |
| if(getSupportsMultipleContents() && XML_TEXT_FRAME_GRAPHIC == nFrameType) | |
| { | |
| addContent(*m_xImplContext); | |
| } | |
| } | |
| } | |
| } | |
| else if(getSupportsMultipleContents() && XML_NAMESPACE_DRAW == p_nPrefix && IsXMLToken(rLocalName, XML_IMAGE)) | |
| { | |
| // read another image | |
| pContext = new XMLTextFrameContext_Impl( | |
| GetImport(), | |
| p_nPrefix, | |
| rLocalName, | |
| xAttrList, | |
| m_eDefaultAnchorType, | |
| XML_TEXT_FRAME_GRAPHIC, | |
| m_xAttrList, | |
| false); | |
| m_xImplContext = pContext; | |
| addContent(*m_xImplContext); | |
| } | |
| else if( m_bSupportsReplacement && !m_xReplImplContext && | |
| XML_NAMESPACE_DRAW == p_nPrefix && | |
| IsXMLToken( rLocalName, XML_IMAGE ) ) | |
| { | |
| // read replacement image | |
| Reference < XPropertySet > xPropSet; | |
| if( CreateIfNotThere( xPropSet ) ) | |
| { | |
| pContext = new XMLReplacementImageContext( GetImport(), | |
| p_nPrefix, rLocalName, xAttrList, xPropSet ); | |
| m_xReplImplContext = pContext; | |
| } | |
| } | |
| else if( m_xImplContext->ISA( XMLTextFrameContext_Impl ) ) | |
| { | |
| // the child is a writer frame | |
| if( XML_NAMESPACE_SVG == p_nPrefix ) | |
| { | |
| // --> OD 2009-07-22 #i73249# | |
| // bool bOld = SvXMLImport::OOo_2x >= GetImport().getGeneratorVersion(); | |
| // if( IsXMLToken( rLocalName, bOld ? XML_DESC : XML_TITLE ) ) | |
| // pContext = new XMLTextFrameDescContext_Impl( GetImport(), p_nPrefix, rLocalName, | |
| // xAttrList, m_sDesc ); | |
| const bool bOld = SvXMLImport::OOo_2x >= GetImport().getGeneratorVersion(); | |
| if ( bOld ) | |
| { | |
| if ( IsXMLToken( rLocalName, XML_DESC ) ) | |
| { | |
| pContext = new XMLTextFrameTitleOrDescContext_Impl( GetImport(), | |
| p_nPrefix, | |
| rLocalName, | |
| m_sTitle ); | |
| } | |
| } | |
| else | |
| { | |
| if( IsXMLToken( rLocalName, XML_TITLE ) ) | |
| { | |
| pContext = new XMLTextFrameTitleOrDescContext_Impl( GetImport(), | |
| p_nPrefix, | |
| rLocalName, | |
| m_sTitle ); | |
| } | |
| else if ( IsXMLToken( rLocalName, XML_DESC ) ) | |
| { | |
| pContext = new XMLTextFrameTitleOrDescContext_Impl( GetImport(), | |
| p_nPrefix, | |
| rLocalName, | |
| m_sDesc ); | |
| } | |
| } | |
| // <-- | |
| } | |
| else if( XML_NAMESPACE_DRAW == p_nPrefix ) | |
| { | |
| Reference < XPropertySet > xPropSet; | |
| if( IsXMLToken( rLocalName, XML_CONTOUR_POLYGON ) ) | |
| { | |
| if( CreateIfNotThere( xPropSet ) ) | |
| pContext = new XMLTextFrameContourContext_Impl( GetImport(), p_nPrefix, rLocalName, | |
| xAttrList, xPropSet, sal_False ); | |
| } | |
| else if( IsXMLToken( rLocalName, XML_CONTOUR_PATH ) ) | |
| { | |
| if( CreateIfNotThere( xPropSet ) ) | |
| pContext = new XMLTextFrameContourContext_Impl( GetImport(), p_nPrefix, rLocalName, | |
| xAttrList, xPropSet, sal_True ); | |
| } | |
| else if( IsXMLToken( rLocalName, XML_IMAGE_MAP ) ) | |
| { | |
| if( CreateIfNotThere( xPropSet ) ) | |
| pContext = new XMLImageMapContext( GetImport(), p_nPrefix, rLocalName, xPropSet ); | |
| } | |
| } | |
| else if( (XML_NAMESPACE_OFFICE == p_nPrefix) && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) | |
| { | |
| // do we still have the frame object? | |
| Reference < XPropertySet > xPropSet; | |
| if( CreateIfNotThere( xPropSet ) ) | |
| { | |
| // is it an event supplier? | |
| Reference<XEventsSupplier> xEventsSupplier(xPropSet, UNO_QUERY); | |
| if (xEventsSupplier.is()) | |
| { | |
| // OK, we have the events, so create the context | |
| pContext = new XMLEventsImportContext(GetImport(), p_nPrefix, | |
| rLocalName, xEventsSupplier); | |
| } | |
| } | |
| } | |
| } | |
| else if( p_nPrefix == XML_NAMESPACE_SVG && // #i68101# | |
| (IsXMLToken( rLocalName, XML_TITLE ) || IsXMLToken( rLocalName, XML_DESC ) ) ) | |
| { | |
| pContext = m_xImplContext->CreateChildContext( p_nPrefix, rLocalName, xAttrList ); | |
| } | |
| else | |
| { | |
| // the child is a drawing shape | |
| pContext = GetImport().GetShapeImport()->CreateFrameChildContext( | |
| &m_xImplContext, p_nPrefix, rLocalName, xAttrList ); | |
| } | |
| if( !pContext ) | |
| pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName ); | |
| return pContext; | |
| } | |
| void XMLTextFrameContext::SetHyperlink( const OUString& rHRef, | |
| const OUString& rName, | |
| const OUString& rTargetFrameName, | |
| sal_Bool bMap ) | |
| { | |
| OSL_ENSURE( !m_pHyperlink, "recursive SetHyperlink call" ); | |
| delete m_pHyperlink; | |
| m_pHyperlink = new XMLTextFrameContextHyperlink_Impl( | |
| rHRef, rName, rTargetFrameName, bMap ); | |
| } | |
| TextContentAnchorType XMLTextFrameContext::GetAnchorType() const | |
| { | |
| SvXMLImportContext *pContext = &m_xImplContext; | |
| XMLTextFrameContext_Impl *pImpl = PTR_CAST( XMLTextFrameContext_Impl, pContext ); | |
| if( pImpl ) | |
| return pImpl->GetAnchorType(); | |
| else | |
| return m_eDefaultAnchorType; | |
| } | |
| Reference < XTextContent > XMLTextFrameContext::GetTextContent() const | |
| { | |
| Reference < XTextContent > xTxtCntnt; | |
| SvXMLImportContext *pContext = &m_xImplContext; | |
| XMLTextFrameContext_Impl *pImpl = PTR_CAST( XMLTextFrameContext_Impl, pContext ); | |
| if( pImpl ) | |
| xTxtCntnt.set( pImpl->GetPropSet(), UNO_QUERY ); | |
| return xTxtCntnt; | |
| } | |
| // --> OD 2004-08-24 #33242# | |
| Reference < XShape > XMLTextFrameContext::GetShape() const | |
| { | |
| Reference < XShape > xShape; | |
| SvXMLImportContext* pContext = &m_xImplContext; | |
| SvXMLShapeContext* pImpl = PTR_CAST( SvXMLShapeContext, pContext ); | |
| if ( pImpl ) | |
| { | |
| xShape = pImpl->getShape(); | |
| } | |
| return xShape; | |
| } | |
| // <-- |