| /************************************************************** |
| * |
| * 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_svtools.hxx" |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <com/sun/star/container/XIndexContainer.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/document/XEventsSupplier.hpp> |
| #include <com/sun/star/lang/XUnoTunnel.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/awt/Rectangle.hpp> |
| #include <com/sun/star/awt/Point.hpp> |
| #include <com/sun/star/drawing/PointSequence.hpp> |
| #include <comphelper/servicehelper.hxx> |
| #include <comphelper/propertysethelper.hxx> |
| #include <comphelper/propertysetinfo.hxx> |
| #include <cppuhelper/weakagg.hxx> |
| #include <cppuhelper/implbase3.hxx> |
| #include <list> |
| #include <rtl/uuid.h> |
| #include <vos/mutex.hxx> |
| #include <vcl/svapp.hxx> |
| #include <svtools/unoevent.hxx> |
| #include <svtools/unoimap.hxx> |
| #include <svtools/imap.hxx> |
| #include <svtools/imapcirc.hxx> |
| #include <svtools/imaprect.hxx> |
| #include <svtools/imappoly.hxx> |
| |
| #ifndef SEQTYPE |
| #if defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500) |
| #define SEQTYPE(x) (new ::com::sun::star::uno::Type( x )) |
| #else |
| #define SEQTYPE(x) &(x) |
| #endif |
| #endif |
| |
| #define MAP_LEN(x) x, sizeof(x)-1 |
| |
| |
| using namespace comphelper; |
| using namespace cppu; |
| using namespace com::sun::star; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::container; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::document; |
| using namespace com::sun::star::drawing; |
| |
| const sal_Int32 HANDLE_URL = 1; |
| const sal_Int32 HANDLE_DESCRIPTION = 2; |
| const sal_Int32 HANDLE_TARGET = 3; |
| const sal_Int32 HANDLE_NAME = 4; |
| const sal_Int32 HANDLE_ISACTIVE = 5; |
| const sal_Int32 HANDLE_POLYGON = 6; |
| const sal_Int32 HANDLE_CENTER = 7; |
| const sal_Int32 HANDLE_RADIUS = 8; |
| const sal_Int32 HANDLE_BOUNDARY = 9; |
| const sal_Int32 HANDLE_TITLE = 10; |
| |
| class SvUnoImageMapObject : public OWeakAggObject, |
| public XEventsSupplier, |
| public XServiceInfo, |
| public PropertySetHelper, |
| public XTypeProvider, |
| public XUnoTunnel |
| { |
| public: |
| SvUnoImageMapObject( sal_uInt16 nType, const SvEventDescription* pSupportedMacroItems ); |
| SvUnoImageMapObject( const IMapObject& rMapObject, const SvEventDescription* pSupportedMacroItems ); |
| virtual ~SvUnoImageMapObject() throw(); |
| |
| UNO3_GETIMPLEMENTATION_DECL( SvUnoImageMapObject ) |
| |
| IMapObject* createIMapObject() const; |
| |
| SvMacroTableEventDescriptor* mpEvents; |
| |
| // overiden helpers from PropertySetHelper |
| virtual void _setPropertyValues( const PropertyMapEntry** ppEntries, const Any* pValues ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException ); |
| virtual void _getPropertyValues( const PropertyMapEntry** ppEntries, Any* pValue ) throw(UnknownPropertyException, WrappedTargetException ); |
| |
| // XInterface |
| virtual Any SAL_CALL queryAggregation( const Type & rType ) throw(RuntimeException); |
| virtual Any SAL_CALL queryInterface( const Type & rType ) throw(RuntimeException); |
| virtual void SAL_CALL acquire() throw(); |
| virtual void SAL_CALL release() throw(); |
| |
| // XTypeProvider |
| virtual Sequence< Type > SAL_CALL getTypes( ) throw(RuntimeException); |
| virtual Sequence< sal_Int8 > SAL_CALL getImplementationId( ) throw(RuntimeException); |
| |
| // XEventsSupplier |
| virtual Reference< ::com::sun::star::container::XNameReplace > SAL_CALL getEvents( ) throw(RuntimeException); |
| |
| // XServiceInfo |
| virtual ::rtl::OUString SAL_CALL getImplementationName( ) throw( RuntimeException ); |
| virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw( RuntimeException ); |
| virtual Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( ) throw( RuntimeException ); |
| |
| private: |
| static PropertySetInfo* createPropertySetInfo( sal_uInt16 nType ); |
| |
| |
| sal_uInt16 mnType; |
| |
| ::rtl::OUString maURL; |
| ::rtl::OUString maAltText; |
| ::rtl::OUString maDesc; |
| ::rtl::OUString maTarget; |
| ::rtl::OUString maName; |
| sal_Bool mbIsActive; |
| awt::Rectangle maBoundary; |
| awt::Point maCenter; |
| sal_Int32 mnRadius; |
| PointSequence maPolygon; |
| }; |
| |
| UNO3_GETIMPLEMENTATION_IMPL( SvUnoImageMapObject ); |
| |
| PropertySetInfo* SvUnoImageMapObject::createPropertySetInfo( sal_uInt16 nType ) |
| { |
| switch( nType ) |
| { |
| case IMAP_OBJ_POLYGON: |
| { |
| static PropertyMapEntry aPolygonObj_Impl[] = |
| { |
| { MAP_LEN( "URL" ), HANDLE_URL, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Title" ), HANDLE_TITLE, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Description" ), HANDLE_DESCRIPTION, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Target" ), HANDLE_TARGET, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Name" ), HANDLE_NAME, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "IsActive" ), HANDLE_ISACTIVE, &::getBooleanCppuType(), 0, 0 }, |
| { MAP_LEN( "Polygon" ), HANDLE_POLYGON, SEQTYPE(::getCppuType((const PointSequence*)0)), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| |
| return new PropertySetInfo( aPolygonObj_Impl ); |
| } |
| case IMAP_OBJ_CIRCLE: |
| { |
| static PropertyMapEntry aCircleObj_Impl[] = |
| { |
| { MAP_LEN( "URL" ), HANDLE_URL, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Title" ), HANDLE_TITLE, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Description" ), HANDLE_DESCRIPTION, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Target" ), HANDLE_TARGET, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Name" ), HANDLE_NAME, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "IsActive" ), HANDLE_ISACTIVE, &::getBooleanCppuType(), 0, 0 }, |
| { MAP_LEN( "Center" ), HANDLE_CENTER, &::getCppuType((const awt::Point*)0), 0, 0 }, |
| { MAP_LEN( "Radius" ), HANDLE_RADIUS, &::getCppuType((const sal_Int32*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| |
| return new PropertySetInfo( aCircleObj_Impl ); |
| } |
| case IMAP_OBJ_RECTANGLE: |
| default: |
| { |
| static PropertyMapEntry aRectangleObj_Impl[] = |
| { |
| { MAP_LEN( "URL" ), HANDLE_URL, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Title" ), HANDLE_TITLE, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Description" ), HANDLE_DESCRIPTION, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Target" ), HANDLE_TARGET, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "Name" ), HANDLE_NAME, &::getCppuType((const ::rtl::OUString*)0), 0, 0 }, |
| { MAP_LEN( "IsActive" ), HANDLE_ISACTIVE, &::getBooleanCppuType(), 0, 0 }, |
| { MAP_LEN( "Boundary" ), HANDLE_BOUNDARY, &::getCppuType((const awt::Rectangle*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| |
| return new PropertySetInfo( aRectangleObj_Impl ); |
| } |
| } |
| } |
| |
| SvUnoImageMapObject::SvUnoImageMapObject( sal_uInt16 nType, const SvEventDescription* pSupportedMacroItems ) |
| : PropertySetHelper( createPropertySetInfo( nType ) ), |
| mnType( nType ) |
| , mbIsActive( true ) |
| , mnRadius( 0 ) |
| { |
| mpEvents = new SvMacroTableEventDescriptor( pSupportedMacroItems ); |
| mpEvents->acquire(); |
| } |
| |
| SvUnoImageMapObject::SvUnoImageMapObject( const IMapObject& rMapObject, const SvEventDescription* pSupportedMacroItems ) |
| : PropertySetHelper( createPropertySetInfo( rMapObject.GetType() ) ), |
| mnType( rMapObject.GetType() ) |
| , mbIsActive( true ) |
| , mnRadius( 0 ) |
| { |
| maURL = rMapObject.GetURL(); |
| maAltText = rMapObject.GetAltText(); |
| maDesc = rMapObject.GetDesc(); |
| maTarget = rMapObject.GetTarget(); |
| maName = rMapObject.GetName(); |
| mbIsActive = rMapObject.IsActive(); |
| |
| switch( mnType ) |
| { |
| case IMAP_OBJ_RECTANGLE: |
| { |
| const Rectangle aRect( ((IMapRectangleObject*)&rMapObject)->GetRectangle(sal_False) ); |
| maBoundary.X = aRect.Left(); |
| maBoundary.Y = aRect.Top(); |
| maBoundary.Width = aRect.GetWidth(); |
| maBoundary.Height = aRect.GetHeight(); |
| } |
| break; |
| case IMAP_OBJ_CIRCLE: |
| { |
| mnRadius = (sal_Int32)((IMapCircleObject*)&rMapObject)->GetRadius(sal_False); |
| const Point aPoint( ((IMapCircleObject*)&rMapObject)->GetCenter(sal_False) ); |
| |
| maCenter.X = aPoint.X(); |
| maCenter.Y = aPoint.Y(); |
| } |
| break; |
| case IMAP_OBJ_POLYGON: |
| default: |
| { |
| const Polygon aPoly( ((IMapPolygonObject*)&rMapObject)->GetPolygon(sal_False) ); |
| |
| const sal_uInt16 nCount = aPoly.GetSize(); |
| maPolygon.realloc( nCount ); |
| awt::Point* pPoints = maPolygon.getArray(); |
| |
| for( sal_uInt16 nPoint = 0; nPoint < nCount; nPoint++ ) |
| { |
| const Point& rPoint = aPoly.GetPoint( nPoint ); |
| pPoints->X = rPoint.X(); |
| pPoints->Y = rPoint.Y(); |
| |
| pPoints++; |
| } |
| } |
| } |
| |
| mpEvents = new SvMacroTableEventDescriptor( rMapObject.GetMacroTable(), pSupportedMacroItems ); |
| mpEvents->acquire(); |
| } |
| |
| SvUnoImageMapObject::~SvUnoImageMapObject() throw() |
| { |
| mpEvents->release(); |
| } |
| |
| IMapObject* SvUnoImageMapObject::createIMapObject() const |
| { |
| const String aURL( maURL ); |
| const String aAltText( maAltText ); |
| const String aDesc( maDesc ); |
| const String aTarget( maTarget ); |
| const String aName( maName ); |
| |
| IMapObject* pNewIMapObject; |
| |
| switch( mnType ) |
| { |
| case IMAP_OBJ_RECTANGLE: |
| { |
| const Rectangle aRect( maBoundary.X, maBoundary.Y, maBoundary.X + maBoundary.Width - 1, maBoundary.Y + maBoundary.Height - 1 ); |
| pNewIMapObject = new IMapRectangleObject( aRect, aURL, aAltText, aDesc, aTarget, aName, mbIsActive, sal_False ); |
| } |
| break; |
| |
| case IMAP_OBJ_CIRCLE: |
| { |
| const Point aCenter( maCenter.X, maCenter.Y ); |
| pNewIMapObject = new IMapCircleObject( aCenter, mnRadius, aURL, aAltText, aDesc, aTarget, aName, mbIsActive, sal_False ); |
| } |
| break; |
| |
| case IMAP_OBJ_POLYGON: |
| default: |
| { |
| const sal_uInt16 nCount = (sal_uInt16)maPolygon.getLength(); |
| |
| Polygon aPoly( nCount ); |
| for( sal_uInt16 nPoint = 0; nPoint < nCount; nPoint++ ) |
| { |
| Point aPoint( maPolygon[nPoint].X, maPolygon[nPoint].Y ); |
| aPoly.SetPoint( aPoint, nPoint ); |
| } |
| |
| aPoly.Optimize( POLY_OPTIMIZE_CLOSE ); |
| pNewIMapObject = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, aName, mbIsActive, sal_False ); |
| } |
| break; |
| } |
| |
| SvxMacroTableDtor aMacroTable; |
| mpEvents->copyMacrosIntoTable(aMacroTable); |
| pNewIMapObject->SetMacroTable( aMacroTable ); |
| |
| return pNewIMapObject; |
| } |
| |
| // XInterface |
| |
| Any SAL_CALL SvUnoImageMapObject::queryInterface( const Type & rType ) |
| throw( RuntimeException ) |
| { |
| return OWeakAggObject::queryInterface( rType ); |
| } |
| |
| Any SAL_CALL SvUnoImageMapObject::queryAggregation( const Type & rType ) |
| throw(RuntimeException) |
| { |
| Any aAny; |
| |
| if( rType == ::getCppuType((const Reference< XServiceInfo >*)0) ) |
| aAny <<= Reference< XServiceInfo >(this); |
| else if( rType == ::getCppuType((const Reference< XTypeProvider >*)0) ) |
| aAny <<= Reference< XTypeProvider >(this); |
| else if( rType == ::getCppuType((const Reference< XPropertySet >*)0) ) |
| aAny <<= Reference< XPropertySet >(this); |
| else if( rType == ::getCppuType((const Reference< XEventsSupplier >*)0) ) |
| aAny <<= Reference< XEventsSupplier >(this); |
| else if( rType == ::getCppuType((const Reference< XMultiPropertySet >*)0) ) |
| aAny <<= Reference< XMultiPropertySet >(this); |
| else if( rType == ::getCppuType((const Reference< XUnoTunnel >*)0) ) |
| aAny <<= Reference< XUnoTunnel >(this); |
| else |
| aAny <<= OWeakAggObject::queryAggregation( rType ); |
| |
| return aAny; |
| } |
| |
| void SAL_CALL SvUnoImageMapObject::acquire() throw() |
| { |
| OWeakAggObject::acquire(); |
| } |
| |
| void SAL_CALL SvUnoImageMapObject::release() throw() |
| { |
| OWeakAggObject::release(); |
| } |
| |
| uno::Sequence< uno::Type > SAL_CALL SvUnoImageMapObject::getTypes() |
| throw (uno::RuntimeException) |
| { |
| uno::Sequence< uno::Type > aTypes( 7 ); |
| uno::Type* pTypes = aTypes.getArray(); |
| |
| *pTypes++ = ::getCppuType((const uno::Reference< XAggregation>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XEventsSupplier>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XServiceInfo>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XPropertySet>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XMultiPropertySet>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XTypeProvider>*)0); |
| *pTypes++ = ::getCppuType((const uno::Reference< XUnoTunnel>*)0); |
| |
| return aTypes; |
| } |
| |
| uno::Sequence< sal_Int8 > SAL_CALL SvUnoImageMapObject::getImplementationId() |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| static uno::Sequence< sal_Int8 > aId; |
| if( aId.getLength() == 0 ) |
| { |
| aId.realloc( 16 ); |
| rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); |
| } |
| return aId; |
| } |
| |
| // XServiceInfo |
| |
| sal_Bool SAL_CALL SvUnoImageMapObject::supportsService( const ::rtl::OUString& ServiceName ) throw(RuntimeException) |
| { |
| const Sequence< ::rtl::OUString > aSNL( getSupportedServiceNames() ); |
| const ::rtl::OUString * pArray = aSNL.getConstArray(); |
| |
| const sal_Int32 nCount = aSNL.getLength(); |
| for( sal_Int32 i = 0; i < nCount; i++ ) |
| if( pArray[i] == ServiceName ) |
| return sal_True; |
| |
| return sal_False; |
| } |
| |
| Sequence< ::rtl::OUString > SAL_CALL SvUnoImageMapObject::getSupportedServiceNames() |
| throw(RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSNS( 2 ); |
| aSNS.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.image.ImageMapObject" )); |
| switch( mnType ) |
| { |
| case IMAP_OBJ_POLYGON: |
| default: |
| aSNS.getArray()[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.image.ImageMapPolygonObject" )); |
| break; |
| case IMAP_OBJ_RECTANGLE: |
| aSNS.getArray()[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.image.ImageMapRectangleObject" )); |
| break; |
| case IMAP_OBJ_CIRCLE: |
| aSNS.getArray()[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.image.ImageMapCircleObject" )); |
| break; |
| } |
| return aSNS; |
| } |
| |
| ::rtl::OUString SAL_CALL SvUnoImageMapObject::getImplementationName() throw(RuntimeException) |
| { |
| switch( mnType ) |
| { |
| case IMAP_OBJ_POLYGON: |
| default: |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("org.openoffice.comp.svt.ImageMapPolygonObject") ); |
| case IMAP_OBJ_CIRCLE: |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("org.openoffice.comp.svt.ImageMapCircleObject") ); |
| case IMAP_OBJ_RECTANGLE: |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("org.openoffice.comp.svt.ImageMapRectangleObject") ); |
| } |
| } |
| |
| // overiden helpers from PropertySetHelper |
| void SvUnoImageMapObject::_setPropertyValues( const PropertyMapEntry** ppEntries, const Any* pValues ) |
| throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException ) |
| { |
| sal_Bool bOk = sal_False; |
| |
| while( *ppEntries ) |
| { |
| switch( (*ppEntries)->mnHandle ) |
| { |
| case HANDLE_URL: |
| bOk = *pValues >>= maURL; |
| break; |
| case HANDLE_TITLE: |
| bOk = *pValues >>= maAltText; |
| break; |
| case HANDLE_DESCRIPTION: |
| bOk = *pValues >>= maDesc; |
| break; |
| case HANDLE_TARGET: |
| bOk = *pValues >>= maTarget; |
| break; |
| case HANDLE_NAME: |
| bOk = *pValues >>= maName; |
| break; |
| case HANDLE_ISACTIVE: |
| bOk = *pValues >>= mbIsActive; |
| break; |
| case HANDLE_BOUNDARY: |
| bOk = *pValues >>= maBoundary; |
| break; |
| case HANDLE_CENTER: |
| bOk = *pValues >>= maCenter; |
| break; |
| case HANDLE_RADIUS: |
| bOk = *pValues >>= mnRadius; |
| break; |
| case HANDLE_POLYGON: |
| bOk = *pValues >>= maPolygon; |
| break; |
| default: |
| DBG_ERROR( "SvUnoImageMapObject::_setPropertyValues: unexpected property handle" ); |
| break; |
| } |
| |
| if( !bOk ) |
| throw IllegalArgumentException(); |
| |
| ppEntries++; |
| pValues++; |
| } |
| } |
| |
| void SvUnoImageMapObject::_getPropertyValues( const PropertyMapEntry** ppEntries, Any* pValues ) |
| throw(UnknownPropertyException, WrappedTargetException ) |
| { |
| while( *ppEntries ) |
| { |
| switch( (*ppEntries)->mnHandle ) |
| { |
| case HANDLE_URL: |
| *pValues <<= maURL; |
| break; |
| case HANDLE_TITLE: |
| *pValues <<= maAltText; |
| break; |
| case HANDLE_DESCRIPTION: |
| *pValues <<= maDesc; |
| break; |
| case HANDLE_TARGET: |
| *pValues <<= maTarget; |
| break; |
| case HANDLE_NAME: |
| *pValues <<= maName; |
| break; |
| case HANDLE_ISACTIVE: |
| *pValues <<= mbIsActive; |
| break; |
| case HANDLE_BOUNDARY: |
| *pValues <<= maBoundary; |
| break; |
| case HANDLE_CENTER: |
| *pValues <<= maCenter; |
| break; |
| case HANDLE_RADIUS: |
| *pValues <<= mnRadius; |
| break; |
| case HANDLE_POLYGON: |
| *pValues <<= maPolygon; |
| break; |
| default: |
| DBG_ERROR( "SvUnoImageMapObject::_getPropertyValues: unexpected property handle" ); |
| break; |
| } |
| |
| ppEntries++; |
| pValues++; |
| } |
| } |
| |
| |
| Reference< XNameReplace > SAL_CALL SvUnoImageMapObject::getEvents() |
| throw( RuntimeException ) |
| { |
| // try weak reference first |
| Reference< XNameReplace > xEvents( mpEvents ); |
| return xEvents; |
| } |
| |
| /////////////////////////////////////////////////////////////////////// |
| |
| class SvUnoImageMap : public WeakImplHelper3< XIndexContainer, XServiceInfo, XUnoTunnel > |
| { |
| public: |
| SvUnoImageMap( const SvEventDescription* pSupportedMacroItems ); |
| SvUnoImageMap( const ImageMap& rMap, const SvEventDescription* pSupportedMacroItems ); |
| virtual ~SvUnoImageMap(); |
| |
| sal_Bool fillImageMap( ImageMap& rMap ) const; |
| SvUnoImageMapObject* getObject( const Any& aElement ) const throw( IllegalArgumentException ); |
| |
| UNO3_GETIMPLEMENTATION_DECL( SvUnoImageMap ) |
| |
| // XIndexContainer |
| virtual void SAL_CALL insertByIndex( sal_Int32 Index, const Any& Element ) throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ); |
| virtual void SAL_CALL removeByIndex( sal_Int32 Index ) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ); |
| |
| // XIndexReplace |
| virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ); |
| |
| // XIndexAccess |
| virtual sal_Int32 SAL_CALL getCount( ) throw( RuntimeException ); |
| virtual Any SAL_CALL getByIndex( sal_Int32 Index ) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ); |
| |
| // XElementAccess |
| virtual Type SAL_CALL getElementType( ) throw( RuntimeException ); |
| virtual sal_Bool SAL_CALL hasElements( ) throw( RuntimeException ); |
| |
| // XSerivceInfo |
| virtual ::rtl::OUString SAL_CALL getImplementationName( ) throw( RuntimeException ); |
| virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw( RuntimeException ); |
| virtual Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( ) throw( RuntimeException ); |
| |
| private: |
| ::rtl::OUString maName; |
| |
| std::list< SvUnoImageMapObject* > maObjectList; |
| }; |
| |
| UNO3_GETIMPLEMENTATION_IMPL( SvUnoImageMap ); |
| |
| SvUnoImageMap::SvUnoImageMap( const SvEventDescription* ) |
| { |
| } |
| |
| SvUnoImageMap::SvUnoImageMap( const ImageMap& rMap, const SvEventDescription* pSupportedMacroItems ) |
| { |
| maName = rMap.GetName(); |
| |
| const sal_uInt16 nCount = rMap.GetIMapObjectCount(); |
| for( sal_uInt16 nPos = 0; nPos < nCount; nPos++ ) |
| { |
| IMapObject* pMapObject = rMap.GetIMapObject( nPos ); |
| SvUnoImageMapObject* pUnoObj = new SvUnoImageMapObject( *pMapObject, pSupportedMacroItems ); |
| pUnoObj->acquire(); |
| maObjectList.push_back( pUnoObj ); |
| } |
| } |
| |
| SvUnoImageMap::~SvUnoImageMap() |
| { |
| std::list< SvUnoImageMapObject* >::iterator aIter = maObjectList.begin(); |
| const std::list< SvUnoImageMapObject* >::iterator aEnd = maObjectList.end(); |
| while( aIter != aEnd ) |
| { |
| (*aIter++)->release(); |
| } |
| } |
| |
| SvUnoImageMapObject* SvUnoImageMap::getObject( const Any& aElement ) const |
| throw( IllegalArgumentException ) |
| { |
| Reference< XInterface > xObject; |
| aElement >>= xObject; |
| |
| SvUnoImageMapObject* pObject = SvUnoImageMapObject::getImplementation( xObject ); |
| if( NULL == pObject ) |
| throw IllegalArgumentException(); |
| |
| return pObject; |
| } |
| |
| // XIndexContainer |
| void SAL_CALL SvUnoImageMap::insertByIndex( sal_Int32 Index, const Any& Element ) |
| throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) |
| { |
| SvUnoImageMapObject* pObject = getObject( Element ); |
| const sal_Int32 nCount = maObjectList.size(); |
| if( NULL == pObject || Index > nCount ) |
| throw IndexOutOfBoundsException(); |
| |
| pObject->acquire(); |
| |
| if( Index == nCount ) |
| maObjectList.push_back( pObject ); |
| else |
| { |
| std::list< SvUnoImageMapObject* >::iterator aIter = maObjectList.begin(); |
| for( sal_Int32 n = 0; n < Index; n++ ) |
| aIter++; |
| |
| maObjectList.insert( aIter, pObject ); |
| } |
| } |
| |
| void SAL_CALL SvUnoImageMap::removeByIndex( sal_Int32 Index ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException) |
| { |
| const sal_Int32 nCount = maObjectList.size(); |
| if( Index >= nCount ) |
| throw IndexOutOfBoundsException(); |
| |
| if( nCount - 1 == Index ) |
| { |
| maObjectList.back()->release(); |
| maObjectList.pop_back(); |
| } |
| else |
| { |
| std::list< SvUnoImageMapObject* >::iterator aIter = maObjectList.begin(); |
| for( sal_Int32 n = 0; n < Index; n++ ) |
| aIter++; |
| |
| (*aIter)->release(); |
| maObjectList.erase( aIter ); |
| } |
| } |
| |
| // XIndexReplace |
| void SAL_CALL SvUnoImageMap::replaceByIndex( sal_Int32 Index, const Any& Element ) throw(IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException) |
| { |
| SvUnoImageMapObject* pObject = getObject( Element ); |
| const sal_Int32 nCount = maObjectList.size(); |
| if( NULL == pObject || Index >= nCount ) |
| throw IndexOutOfBoundsException(); |
| |
| std::list< SvUnoImageMapObject* >::iterator aIter = maObjectList.begin(); |
| for( sal_Int32 n = 0; n < Index; n++ ) |
| aIter++; |
| |
| (*aIter)->release(); |
| *aIter = pObject; |
| pObject->acquire(); |
| } |
| |
| // XIndexAccess |
| sal_Int32 SAL_CALL SvUnoImageMap::getCount( ) throw(RuntimeException) |
| { |
| return maObjectList.size(); |
| } |
| |
| Any SAL_CALL SvUnoImageMap::getByIndex( sal_Int32 Index ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException) |
| { |
| const sal_Int32 nCount = maObjectList.size(); |
| if( Index >= nCount ) |
| throw IndexOutOfBoundsException(); |
| |
| std::list< SvUnoImageMapObject* >::iterator aIter = maObjectList.begin(); |
| for( sal_Int32 n = 0; n < Index; n++ ) |
| aIter++; |
| |
| Reference< XPropertySet > xObj( *aIter ); |
| return makeAny( xObj ); |
| } |
| |
| // XElementAccess |
| Type SAL_CALL SvUnoImageMap::getElementType( ) throw(RuntimeException) |
| { |
| return ::getCppuType((const Reference< XPropertySet >*)0); |
| } |
| |
| sal_Bool SAL_CALL SvUnoImageMap::hasElements( ) throw(RuntimeException) |
| { |
| return maObjectList.size() != 0; |
| } |
| |
| // XSerivceInfo |
| ::rtl::OUString SAL_CALL SvUnoImageMap::getImplementationName( ) |
| throw(RuntimeException) |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "org.openoffice.comp.svt.SvUnoImageMap" ) ); |
| } |
| |
| sal_Bool SAL_CALL SvUnoImageMap::supportsService( const ::rtl::OUString& ServiceName ) |
| throw(RuntimeException) |
| { |
| const Sequence< ::rtl::OUString > aSNL( getSupportedServiceNames() ); |
| const ::rtl::OUString * pArray = aSNL.getConstArray(); |
| |
| const sal_Int32 nCount = aSNL.getLength(); |
| for( sal_Int32 i = 0; i < nCount; i++ ) |
| if( pArray[i] == ServiceName ) |
| return sal_True; |
| |
| return sal_False; |
| } |
| |
| Sequence< ::rtl::OUString > SAL_CALL SvUnoImageMap::getSupportedServiceNames( ) |
| throw(RuntimeException) |
| { |
| const ::rtl::OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.image.ImageMap" ) ); |
| return Sequence< ::rtl::OUString >( &aSN, 1 ); |
| } |
| |
| sal_Bool SvUnoImageMap::fillImageMap( ImageMap& rMap ) const |
| { |
| rMap.ClearImageMap(); |
| |
| rMap.SetName( maName ); |
| |
| std::list< SvUnoImageMapObject* >::const_iterator aIter = maObjectList.begin(); |
| const std::list< SvUnoImageMapObject* >::const_iterator aEnd = maObjectList.end(); |
| while( aIter != aEnd ) |
| { |
| IMapObject* pNewMapObject = (*aIter)->createIMapObject(); |
| rMap.InsertIMapObject( *pNewMapObject ); |
| delete pNewMapObject; |
| |
| aIter++; |
| } |
| |
| return sal_True; |
| } |
| |
| // ------------------------------------------------------------------- |
| // factory helper methods |
| // ------------------------------------------------------------------- |
| |
| Reference< XInterface > SvUnoImageMapRectangleObject_createInstance( const SvEventDescription* pSupportedMacroItems ) |
| { |
| return (XWeak*)new SvUnoImageMapObject( IMAP_OBJ_RECTANGLE, pSupportedMacroItems ); |
| } |
| |
| Reference< XInterface > SvUnoImageMapCircleObject_createInstance( const SvEventDescription* pSupportedMacroItems ) |
| { |
| return (XWeak*)new SvUnoImageMapObject( IMAP_OBJ_CIRCLE, pSupportedMacroItems ); |
| } |
| |
| Reference< XInterface > SvUnoImageMapPolygonObject_createInstance( const SvEventDescription* pSupportedMacroItems ) |
| { |
| return (XWeak*)new SvUnoImageMapObject( IMAP_OBJ_POLYGON, pSupportedMacroItems ); |
| } |
| |
| Reference< XInterface > SvUnoImageMap_createInstance( const SvEventDescription* pSupportedMacroItems ) |
| { |
| return (XWeak*)new SvUnoImageMap( pSupportedMacroItems ); |
| } |
| |
| Reference< XInterface > SvUnoImageMap_createInstance( const ImageMap& rMap, const SvEventDescription* pSupportedMacroItems ) |
| { |
| return (XWeak*)new SvUnoImageMap( rMap, pSupportedMacroItems ); |
| } |
| |
| sal_Bool SvUnoImageMap_fillImageMap( Reference< XInterface > xImageMap, ImageMap& rMap ) |
| { |
| SvUnoImageMap* pUnoImageMap = SvUnoImageMap::getImplementation( xImageMap ); |
| if( NULL == pUnoImageMap ) |
| return sal_False; |
| |
| return pUnoImageMap->fillImageMap( rMap ); |
| } |