| /************************************************************** |
| * |
| * 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 "XMLImageMapContext.hxx" |
| #include <rtl/ustrbuf.hxx> |
| #include <com/sun/star/uno/Reference.h> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XPropertySetInfo.hpp> |
| #include <com/sun/star/xml/sax/XAttributeList.hpp> |
| #include <com/sun/star/container/XIndexContainer.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/drawing/PointSequenceSequence.hpp> |
| #include <com/sun/star/document/XEventsSupplier.hpp> |
| #include <com/sun/star/awt/Rectangle.hpp> |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/xmlimp.hxx> |
| #include <xmloff/xmltkmap.hxx> |
| #include "xmloff/xmlnmspe.hxx" |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include "xexptran.hxx" |
| #include "xmloff/xmlerror.hxx" |
| #include <xmloff/XMLEventsImportContext.hxx> |
| #include "XMLStringBufferImportContext.hxx" |
| #include <tools/debug.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| |
| using namespace ::com::sun::star; |
| using namespace ::xmloff::token; |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| using ::com::sun::star::beans::XPropertySet; |
| using ::com::sun::star::beans::XPropertySetInfo; |
| using ::com::sun::star::container::XIndexContainer; |
| using ::com::sun::star::lang::XMultiServiceFactory; |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::xml::sax::XAttributeList; |
| using ::com::sun::star::uno::XInterface; |
| using ::com::sun::star::uno::Any; |
| using ::com::sun::star::drawing::PointSequenceSequence; |
| using ::com::sun::star::document::XEventsSupplier; |
| |
| |
| enum XMLImageMapToken |
| { |
| XML_TOK_IMAP_URL, |
| XML_TOK_IMAP_X, |
| XML_TOK_IMAP_Y, |
| XML_TOK_IMAP_CENTER_X, |
| XML_TOK_IMAP_CENTER_Y, |
| XML_TOK_IMAP_WIDTH, |
| XML_TOK_IMAP_HEIGTH, |
| XML_TOK_IMAP_POINTS, |
| XML_TOK_IMAP_VIEWBOX, |
| XML_TOK_IMAP_NOHREF, |
| XML_TOK_IMAP_NAME, |
| XML_TOK_IMAP_RADIUS, |
| XML_TOK_IMAP_TARGET |
| }; |
| |
| static __FAR_DATA SvXMLTokenMapEntry aImageMapObjectTokenMap[] = |
| { |
| { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_IMAP_URL }, |
| { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_IMAP_NAME }, |
| { XML_NAMESPACE_DRAW, XML_NOHREF, XML_TOK_IMAP_NOHREF }, |
| { XML_NAMESPACE_SVG, XML_X, XML_TOK_IMAP_X }, |
| { XML_NAMESPACE_SVG, XML_Y, XML_TOK_IMAP_Y }, |
| { XML_NAMESPACE_SVG, XML_CX, XML_TOK_IMAP_CENTER_X }, |
| { XML_NAMESPACE_SVG, XML_CY, XML_TOK_IMAP_CENTER_Y }, |
| { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_IMAP_WIDTH }, |
| { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_IMAP_HEIGTH }, |
| { XML_NAMESPACE_SVG, XML_R, XML_TOK_IMAP_RADIUS }, |
| { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_IMAP_VIEWBOX }, |
| { XML_NAMESPACE_DRAW, XML_POINTS, XML_TOK_IMAP_POINTS }, |
| { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME, XML_TOK_IMAP_TARGET }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| |
| |
| class XMLImageMapObjectContext : public SvXMLImportContext |
| { |
| |
| protected: |
| |
| const ::rtl::OUString sBoundary; |
| const ::rtl::OUString sCenter; |
| const ::rtl::OUString sTitle; |
| const ::rtl::OUString sDescription; |
| const ::rtl::OUString sImageMap; |
| const ::rtl::OUString sIsActive; |
| const ::rtl::OUString sName; |
| const ::rtl::OUString sPolygon; |
| const ::rtl::OUString sRadius; |
| const ::rtl::OUString sTarget; |
| const ::rtl::OUString sURL; |
| |
| ::rtl::OUString sServiceName; |
| |
| Reference<XIndexContainer> xImageMap; /// the image map |
| Reference<XPropertySet> xMapEntry; /// one map-entry (one area) |
| |
| ::rtl::OUString sUrl; |
| ::rtl::OUString sTargt; |
| ::rtl::OUStringBuffer sDescriptionBuffer; |
| ::rtl::OUStringBuffer sTitleBuffer; |
| ::rtl::OUString sNam; |
| sal_Bool bIsActive; |
| |
| sal_Bool bValid; |
| |
| public: |
| TYPEINFO(); |
| |
| XMLImageMapObjectContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::container::XIndexContainer> xMap, |
| const sal_Char* pServiceName); |
| |
| void StartElement( |
| const ::com::sun::star::uno::Reference< |
| ::com::sun::star::xml::sax::XAttributeList >& xAttrList ); |
| |
| void EndElement(); |
| |
| SvXMLImportContext *CreateChildContext( |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| const ::com::sun::star::uno::Reference< |
| ::com::sun::star::xml::sax::XAttributeList> & xAttrList ); |
| |
| protected: |
| |
| virtual void ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const ::rtl::OUString& rValue); |
| |
| virtual void Prepare( |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::beans::XPropertySet> & rPropertySet); |
| }; |
| |
| |
| TYPEINIT1( XMLImageMapObjectContext, SvXMLImportContext ); |
| |
| XMLImageMapObjectContext::XMLImageMapObjectContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| Reference<XIndexContainer> xMap, |
| const sal_Char* pServiceName) : |
| SvXMLImportContext(rImport, nPrefix, rLocalName), |
| sBoundary(RTL_CONSTASCII_USTRINGPARAM("Boundary")), |
| sCenter(RTL_CONSTASCII_USTRINGPARAM("Center")), |
| sTitle(RTL_CONSTASCII_USTRINGPARAM("Title")), |
| sDescription(RTL_CONSTASCII_USTRINGPARAM("Description")), |
| sImageMap(RTL_CONSTASCII_USTRINGPARAM("ImageMap")), |
| sIsActive(RTL_CONSTASCII_USTRINGPARAM("IsActive")), |
| sName(RTL_CONSTASCII_USTRINGPARAM("Name")), |
| sPolygon(RTL_CONSTASCII_USTRINGPARAM("Polygon")), |
| sRadius(RTL_CONSTASCII_USTRINGPARAM("Radius")), |
| sTarget(RTL_CONSTASCII_USTRINGPARAM("Target")), |
| sURL(RTL_CONSTASCII_USTRINGPARAM("URL")), |
| xImageMap(xMap), |
| bIsActive(sal_True), |
| bValid(sal_False) |
| { |
| DBG_ASSERT(NULL != pServiceName, |
| "Please supply the image map object service name"); |
| |
| Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY); |
| if( xFactory.is() ) |
| { |
| Reference<XInterface> xIfc = xFactory->createInstance( |
| OUString::createFromAscii(pServiceName)); |
| DBG_ASSERT(xIfc.is(), "can't create image map object!"); |
| if( xIfc.is() ) |
| { |
| Reference<XPropertySet> xPropertySet( xIfc, UNO_QUERY ); |
| |
| xMapEntry = xPropertySet; |
| } |
| // else: can't create service -> ignore |
| } |
| // else: can't even get factory -> ignore |
| } |
| |
| void XMLImageMapObjectContext::StartElement( |
| const Reference<XAttributeList >& xAttrList ) |
| { |
| SvXMLTokenMap aMap(aImageMapObjectTokenMap); |
| |
| sal_Int16 nLength = xAttrList->getLength(); |
| for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++) |
| { |
| OUString sLocalName; |
| sal_uInt16 nPrefix = GetImport().GetNamespaceMap(). |
| GetKeyByAttrName( xAttrList->getNameByIndex(nAttr), |
| &sLocalName ); |
| OUString sValue = xAttrList->getValueByIndex(nAttr); |
| |
| ProcessAttribute( |
| (enum XMLImageMapToken)aMap.Get(nPrefix, sLocalName), sValue); |
| } |
| } |
| |
| void XMLImageMapObjectContext::EndElement() |
| { |
| // only create and insert image map object if validity flag is set |
| // (and we actually have an image map) |
| if ( bValid && xImageMap.is() && xMapEntry.is() ) |
| { |
| // set values |
| Prepare( xMapEntry ); |
| |
| // insert into image map |
| Any aAny; |
| aAny <<= xMapEntry; |
| xImageMap->insertByIndex( xImageMap->getCount(), aAny ); |
| } |
| // else: not valid -> don't create and insert |
| } |
| |
| SvXMLImportContext* XMLImageMapObjectContext::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const Reference<XAttributeList> & xAttrList ) |
| { |
| if ( (XML_NAMESPACE_OFFICE == nPrefix) && |
| IsXMLToken(rLocalName, XML_EVENT_LISTENERS) ) |
| { |
| Reference<XEventsSupplier> xEvents( xMapEntry, UNO_QUERY ); |
| return new XMLEventsImportContext( |
| GetImport(), nPrefix, rLocalName, xEvents); |
| } |
| else if ( (XML_NAMESPACE_SVG == nPrefix) && |
| IsXMLToken(rLocalName, XML_TITLE) ) |
| { |
| return new XMLStringBufferImportContext( |
| GetImport(), nPrefix, rLocalName, sTitleBuffer); |
| } |
| else if ( (XML_NAMESPACE_SVG == nPrefix) && |
| IsXMLToken(rLocalName, XML_DESC) ) |
| { |
| return new XMLStringBufferImportContext( |
| GetImport(), nPrefix, rLocalName, sDescriptionBuffer); |
| } |
| else |
| return SvXMLImportContext::CreateChildContext(nPrefix, rLocalName, |
| xAttrList); |
| |
| } |
| |
| void XMLImageMapObjectContext::ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const OUString& rValue) |
| { |
| switch (eToken) |
| { |
| case XML_TOK_IMAP_URL: |
| sUrl = GetImport().GetAbsoluteReference(rValue); |
| break; |
| |
| case XML_TOK_IMAP_TARGET: |
| sTargt = rValue; |
| break; |
| |
| case XML_TOK_IMAP_NOHREF: |
| bIsActive = ! IsXMLToken(rValue, XML_NOHREF); |
| break; |
| |
| case XML_TOK_IMAP_NAME: |
| sNam = rValue; |
| break; |
| default: |
| // do nothing |
| break; |
| } |
| } |
| |
| void XMLImageMapObjectContext::Prepare( |
| Reference<XPropertySet> & rPropertySet) |
| { |
| rPropertySet->setPropertyValue( sURL, Any( sUrl ) ); |
| rPropertySet->setPropertyValue( sTitle, Any( sTitleBuffer.makeStringAndClear() ) ); |
| rPropertySet->setPropertyValue( sDescription, Any( sDescriptionBuffer.makeStringAndClear() ) ); |
| rPropertySet->setPropertyValue( sTarget, Any( sTargt ) ); |
| rPropertySet->setPropertyValue( sIsActive, Any( bIsActive ) ); |
| rPropertySet->setPropertyValue( sName, Any( sNam ) ); |
| } |
| |
| |
| |
| class XMLImageMapRectangleContext : public XMLImageMapObjectContext |
| { |
| awt::Rectangle aRectangle; |
| |
| sal_Bool bXOK; |
| sal_Bool bYOK; |
| sal_Bool bWidthOK; |
| sal_Bool bHeightOK; |
| |
| public: |
| TYPEINFO(); |
| |
| XMLImageMapRectangleContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::container::XIndexContainer> xMap); |
| |
| virtual ~XMLImageMapRectangleContext(); |
| |
| protected: |
| virtual void ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const ::rtl::OUString& rValue); |
| |
| virtual void Prepare( |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::beans::XPropertySet> & rPropertySet); |
| }; |
| |
| |
| |
| TYPEINIT1(XMLImageMapRectangleContext, XMLImageMapObjectContext); |
| |
| XMLImageMapRectangleContext::XMLImageMapRectangleContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| Reference<XIndexContainer> xMap) : |
| XMLImageMapObjectContext(rImport, nPrefix, rLocalName, xMap, |
| "com.sun.star.image.ImageMapRectangleObject"), |
| bXOK(sal_False), |
| bYOK(sal_False), |
| bWidthOK(sal_False), |
| bHeightOK(sal_False) |
| { |
| } |
| |
| XMLImageMapRectangleContext::~XMLImageMapRectangleContext() |
| { |
| } |
| |
| void XMLImageMapRectangleContext::ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const OUString& rValue) |
| { |
| sal_Int32 nTmp; |
| switch (eToken) |
| { |
| case XML_TOK_IMAP_X: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aRectangle.X = nTmp; |
| bXOK = sal_True; |
| } |
| break; |
| case XML_TOK_IMAP_Y: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aRectangle.Y = nTmp; |
| bYOK = sal_True; |
| } |
| break; |
| case XML_TOK_IMAP_WIDTH: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aRectangle.Width = nTmp; |
| bWidthOK = sal_True; |
| } |
| break; |
| case XML_TOK_IMAP_HEIGTH: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aRectangle.Height = nTmp; |
| bHeightOK = sal_True; |
| } |
| break; |
| default: |
| XMLImageMapObjectContext::ProcessAttribute(eToken, rValue); |
| } |
| |
| bValid = bHeightOK && bXOK && bYOK && bWidthOK; |
| } |
| |
| void XMLImageMapRectangleContext::Prepare( |
| Reference<XPropertySet> & rPropertySet) |
| { |
| Any aAny; |
| aAny <<= aRectangle; |
| rPropertySet->setPropertyValue( sBoundary, aAny ); |
| |
| // common properties handled by super class |
| XMLImageMapObjectContext::Prepare(rPropertySet); |
| } |
| |
| |
| class XMLImageMapPolygonContext : public XMLImageMapObjectContext |
| { |
| ::rtl::OUString sViewBoxString; |
| ::rtl::OUString sPointsString; |
| |
| sal_Bool bViewBoxOK; |
| sal_Bool bPointsOK; |
| |
| public: |
| TYPEINFO(); |
| |
| XMLImageMapPolygonContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::container::XIndexContainer> xMap); |
| |
| virtual ~XMLImageMapPolygonContext(); |
| |
| protected: |
| virtual void ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const ::rtl::OUString& rValue); |
| |
| virtual void Prepare( |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::beans::XPropertySet> & rPropertySet); |
| }; |
| |
| |
| |
| TYPEINIT1(XMLImageMapPolygonContext, XMLImageMapObjectContext); |
| |
| XMLImageMapPolygonContext::XMLImageMapPolygonContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| Reference<XIndexContainer> xMap) : |
| XMLImageMapObjectContext(rImport, nPrefix, rLocalName, xMap, |
| "com.sun.star.image.ImageMapPolygonObject"), |
| bViewBoxOK(sal_False), |
| bPointsOK(sal_False) |
| { |
| } |
| |
| XMLImageMapPolygonContext::~XMLImageMapPolygonContext() |
| { |
| } |
| |
| void XMLImageMapPolygonContext::ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const OUString& rValue) |
| { |
| switch (eToken) |
| { |
| case XML_TOK_IMAP_POINTS: |
| sPointsString = rValue; |
| bPointsOK = sal_True; |
| break; |
| case XML_TOK_IMAP_VIEWBOX: |
| sViewBoxString = rValue; |
| bViewBoxOK = sal_True; |
| break; |
| default: |
| XMLImageMapObjectContext::ProcessAttribute(eToken, rValue); |
| break; |
| } |
| |
| bValid = bViewBoxOK && bPointsOK; |
| } |
| |
| void XMLImageMapPolygonContext::Prepare(Reference<XPropertySet> & rPropertySet) |
| { |
| // process view box |
| SdXMLImExViewBox aViewBox(sViewBoxString, GetImport().GetMM100UnitConverter()); |
| |
| // get polygon sequence |
| basegfx::B2DPolygon aPolygon; |
| |
| if(basegfx::tools::importFromSvgPoints(aPolygon, sPointsString)) |
| { |
| if(aPolygon.count()) |
| { |
| com::sun::star::drawing::PointSequence aPointSequence; |
| uno::Any aAny; |
| |
| basegfx::tools::B2DPolygonToUnoPointSequence(aPolygon, aPointSequence); |
| aAny <<= aPointSequence; |
| rPropertySet->setPropertyValue(sPolygon, aAny); |
| } |
| } |
| |
| // parent properties |
| XMLImageMapObjectContext::Prepare(rPropertySet); |
| } |
| |
| class XMLImageMapCircleContext : public XMLImageMapObjectContext |
| { |
| awt::Point aCenter; |
| sal_Int32 nRadius; |
| |
| sal_Bool bXOK; |
| sal_Bool bYOK; |
| sal_Bool bRadiusOK; |
| |
| public: |
| TYPEINFO(); |
| |
| XMLImageMapCircleContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::container::XIndexContainer> xMap); |
| |
| virtual ~XMLImageMapCircleContext(); |
| |
| protected: |
| virtual void ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const ::rtl::OUString& rValue); |
| |
| virtual void Prepare( |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::beans::XPropertySet> & rPropertySet); |
| }; |
| |
| TYPEINIT1(XMLImageMapCircleContext, XMLImageMapObjectContext); |
| |
| XMLImageMapCircleContext::XMLImageMapCircleContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| Reference<XIndexContainer> xMap) : |
| XMLImageMapObjectContext(rImport, nPrefix, rLocalName, xMap, |
| "com.sun.star.image.ImageMapCircleObject"), |
| bXOK(sal_False), |
| bYOK(sal_False), |
| bRadiusOK(sal_False) |
| { |
| } |
| |
| XMLImageMapCircleContext::~XMLImageMapCircleContext() |
| { |
| } |
| |
| void XMLImageMapCircleContext::ProcessAttribute( |
| enum XMLImageMapToken eToken, |
| const OUString& rValue) |
| { |
| sal_Int32 nTmp; |
| switch (eToken) |
| { |
| case XML_TOK_IMAP_CENTER_X: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aCenter.X = nTmp; |
| bXOK = sal_True; |
| } |
| break; |
| case XML_TOK_IMAP_CENTER_Y: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| aCenter.Y = nTmp; |
| bYOK = sal_True; |
| } |
| break; |
| case XML_TOK_IMAP_RADIUS: |
| if (GetImport().GetMM100UnitConverter().convertMeasure(nTmp, |
| rValue)) |
| { |
| nRadius = nTmp; |
| bRadiusOK = sal_True; |
| } |
| break; |
| default: |
| XMLImageMapObjectContext::ProcessAttribute(eToken, rValue); |
| } |
| |
| bValid = bRadiusOK && bXOK && bYOK; |
| } |
| |
| void XMLImageMapCircleContext::Prepare( |
| Reference<XPropertySet> & rPropertySet) |
| { |
| // center (x,y) |
| Any aAny; |
| aAny <<= aCenter; |
| rPropertySet->setPropertyValue( sCenter, aAny ); |
| |
| // radius |
| aAny <<= nRadius; |
| rPropertySet->setPropertyValue( sRadius, aAny ); |
| |
| // common properties handled by super class |
| XMLImageMapObjectContext::Prepare(rPropertySet); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| TYPEINIT1(XMLImageMapContext, SvXMLImportContext); |
| |
| XMLImageMapContext::XMLImageMapContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| Reference<XPropertySet> & rPropertySet) : |
| SvXMLImportContext(rImport, nPrefix, rLocalName), |
| sImageMap(RTL_CONSTASCII_USTRINGPARAM("ImageMap")), |
| xPropertySet(rPropertySet) |
| |
| { |
| try |
| { |
| Reference < XPropertySetInfo > xInfo = |
| xPropertySet->getPropertySetInfo(); |
| if( xInfo.is() && xInfo->hasPropertyByName( sImageMap ) ) |
| xPropertySet->getPropertyValue(sImageMap) >>= xImageMap; |
| } |
| catch( com::sun::star::uno::Exception e ) |
| { |
| uno::Sequence<OUString> aSeq(0); |
| rImport.SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, aSeq, e.Message, NULL ); |
| } |
| } |
| |
| XMLImageMapContext::~XMLImageMapContext() |
| { |
| } |
| |
| SvXMLImportContext *XMLImageMapContext::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const Reference<XAttributeList> & xAttrList ) |
| { |
| SvXMLImportContext* pContext = NULL; |
| |
| if ( XML_NAMESPACE_DRAW == nPrefix ) |
| { |
| if ( IsXMLToken(rLocalName, XML_AREA_RECTANGLE) ) |
| { |
| pContext = new XMLImageMapRectangleContext( |
| GetImport(), nPrefix, rLocalName, xImageMap); |
| } |
| else if ( IsXMLToken(rLocalName, XML_AREA_POLYGON) ) |
| { |
| pContext = new XMLImageMapPolygonContext( |
| GetImport(), nPrefix, rLocalName, xImageMap); |
| } |
| else if ( IsXMLToken(rLocalName, XML_AREA_CIRCLE) ) |
| { |
| pContext = new XMLImageMapCircleContext( |
| GetImport(), nPrefix, rLocalName, xImageMap); |
| } |
| } |
| else |
| pContext = SvXMLImportContext::CreateChildContext(nPrefix, rLocalName, |
| xAttrList); |
| |
| return pContext; |
| } |
| |
| void XMLImageMapContext::EndElement() |
| { |
| Reference < XPropertySetInfo > xInfo = |
| xPropertySet->getPropertySetInfo(); |
| if( xInfo.is() && xInfo->hasPropertyByName( sImageMap ) ) |
| xPropertySet->setPropertyValue(sImageMap, uno::makeAny( xImageMap ) ); |
| } |
| |