unotools/source/property/propertysethelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: propertysethelper.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_unotools.hxx"
  33 #include <tools/debug.hxx>
  34
  35 #include "unotools/propertysetinfo.hxx"
  36 #include "unotools/propertysethelper.hxx"
  37
  38 ///////////////////////////////////////////////////////////////////////
  39
  40 using namespace ::utl;
  41 using namespace ::rtl;
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::uno;
  44 using namespace ::com::sun::star::beans;
  45 using namespace ::com::sun::star::lang;
  46
  47 namespace utl
  48 {
  49 class PropertySetHelperImpl
  50 {
  51 public:
  52     PropertyMapEntry* find( const OUString& aName ) const throw();
  53
  54     PropertySetInfo* mpInfo;
  55 };
  56 }
  57
  58 PropertyMapEntry* PropertySetHelperImpl::find( const OUString& aName ) const throw()
  59 {
  60     PropertyMap::const_iterator aIter = mpInfo->getPropertyMap()->find( aName );
  61
  62     if( mpInfo->getPropertyMap()->end() != aIter )
  63     {
  64         return (*aIter).second;
  65     }
  66     else
  67     {
  68         return NULL;
  69     }
  70 }
  71
  72 ///////////////////////////////////////////////////////////////////////
  73
  74 PropertySetHelper::PropertySetHelper( utl::PropertySetInfo* pInfo ) throw()
  75 {
  76     mp = new PropertySetHelperImpl;
  77     mp->mpInfo = pInfo;
  78     pInfo->acquire();
  79 }
  80
  81 PropertySetHelper::~PropertySetHelper() throw()
  82 {
  83     mp->mpInfo->release();
  84     delete mp;
  85 }
  86
  87 // XPropertySet
  88 Reference< XPropertySetInfo > SAL_CALL PropertySetHelper::getPropertySetInfo(  ) throw(RuntimeException)
  89 {
  90     return mp->mpInfo;
  91 }
  92
  93 void SAL_CALL PropertySetHelper::setPropertyValue( const ::rtl::OUString& aPropertyName, const Any& aValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
  94 {
  95     PropertyMapEntry* aEntries[2];
  96     aEntries[0] = mp->find( aPropertyName );
  97
  98     if( NULL == aEntries[0] )
  99         throw UnknownPropertyException();
 100
 101     aEntries[1] = NULL;
 102
 103     _setPropertyValues( (const PropertyMapEntry**)aEntries, &aValue );
 104 }
 105
 106 Any SAL_CALL PropertySetHelper::getPropertyValue( const ::rtl::OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 107 {
 108     PropertyMapEntry* aEntries[2];
 109     aEntries[0] = mp->find( PropertyName );
 110
 111     if( NULL == aEntries[0] )
 112         throw UnknownPropertyException();
 113
 114     aEntries[1] = NULL;
 115
 116     Any aAny;
 117     _getPropertyValues( (const PropertyMapEntry**)aEntries, &aAny );
 118
 119     return aAny;
 120 }
 121
 122 void SAL_CALL PropertySetHelper::addPropertyChangeListener( const ::rtl::OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 123 {
 124     // todo
 125 }
 126
 127 void SAL_CALL PropertySetHelper::removePropertyChangeListener( const ::rtl::OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 128 {
 129     // todo
 130 }
 131
 132 void SAL_CALL PropertySetHelper::addVetoableChangeListener( const ::rtl::OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 133 {
 134     // todo
 135 }
 136
 137 void SAL_CALL PropertySetHelper::removeVetoableChangeListener( const ::rtl::OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 138 {
 139     // todo
 140 }
 141
 142 // XMultiPropertySet
 143 void SAL_CALL PropertySetHelper::setPropertyValues( const Sequence< ::rtl::OUString >& aPropertyNames, const Sequence< Any >& aValues ) throw(PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 144 {
 145     const sal_Int32 nCount = aPropertyNames.getLength();
 146
 147     if( nCount != aValues.getLength() )
 148         throw IllegalArgumentException();
 149
 150     if( nCount )
 151     {
 152         PropertyMapEntry** pEntries = new PropertyMapEntry*[nCount+1];
 153         const OUString* pNames = aPropertyNames.getConstArray();
 154
 155         sal_Bool bUnknown = sal_False;
 156         sal_Int32 n;
 157         for( n = 0; !bUnknown && ( n < nCount ); n++, pNames++ )
 158         {
 159             pEntries[n] = mp->find( *pNames );
 160             bUnknown = NULL == pEntries[n];
 161         }
 162
 163         if( !bUnknown )
 164             _setPropertyValues( (const PropertyMapEntry**)pEntries, aValues.getConstArray() );
 165
 166         delete [] pEntries;
 167
 168         if( bUnknown )
 169             throw UnknownPropertyException();
 170     }
 171 }
 172
 173 Sequence< Any > SAL_CALL PropertySetHelper::getPropertyValues( const Sequence< ::rtl::OUString >& aPropertyNames ) throw(RuntimeException)
 174 {
 175     const sal_Int32 nCount = aPropertyNames.getLength();
 176
 177     Sequence< Any > aValues;
 178     if( nCount )
 179     {
 180         PropertyMapEntry** pEntries = new PropertyMapEntry*[nCount+1];
 181         const OUString* pNames = aPropertyNames.getConstArray();
 182
 183         sal_Bool bUnknown = sal_False;
 184         sal_Int32 n;
 185         for( n = 0; !bUnknown && ( n < nCount ); n++, pNames++ )
 186         {
 187             pEntries[n] = mp->find( *pNames );
 188             bUnknown = NULL == pEntries[n];
 189         }
 190
 191         if( !bUnknown )
 192             _getPropertyValues( (const PropertyMapEntry**)pEntries, aValues.getArray() );
 193
 194         delete [] pEntries;
 195
 196         if( bUnknown )
 197             throw UnknownPropertyException();
 198     }
 199
 200     return aValues;
 201 }
 202
 203 void SAL_CALL PropertySetHelper::addPropertiesChangeListener( const Sequence< ::rtl::OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw(RuntimeException)
 204 {
 205     // todo
 206 }
 207
 208 void SAL_CALL PropertySetHelper::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw(RuntimeException)
 209 {
 210     // todo
 211 }
 212
 213 void SAL_CALL PropertySetHelper::firePropertiesChangeEvent( const Sequence< ::rtl::OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw(RuntimeException)
 214 {
 215     // todo
 216 }
 217
 218 // XPropertyState
 219 PropertyState SAL_CALL PropertySetHelper::getPropertyState( const ::rtl::OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
 220 {
 221     PropertyMapEntry* aEntries[2];
 222
 223     aEntries[0] = mp->find( PropertyName );
 224     if( aEntries[0] == NULL )
 225         throw UnknownPropertyException();
 226
 227     aEntries[1] = NULL;
 228
 229     PropertyState aState;
 230     _getPropertyStates( (const PropertyMapEntry**)aEntries, &aState );
 231
 232     return aState;
 233 }
 234
 235 Sequence< PropertyState > SAL_CALL PropertySetHelper::getPropertyStates( const Sequence< ::rtl::OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
 236 {
 237     const sal_Int32 nCount = aPropertyName.getLength();
 238
 239     Sequence< PropertyState > aStates( nCount );
 240
 241     if( nCount )
 242     {
 243         const OUString* pNames = aPropertyName.getConstArray();
 244
 245         sal_Bool bUnknown = sal_False;
 246
 247         PropertyMapEntry** pEntries = new PropertyMapEntry*[nCount+1];
 248
 249         sal_Int32 n;
 250         for( n = 0; !bUnknown && (n < nCount); n++, pNames++ )
 251         {
 252             pEntries[n] = mp->find( *pNames );
 253             bUnknown = NULL == pEntries[n];
 254         }
 255
 256         pEntries[nCount] = NULL;
 257
 258         if( !bUnknown )
 259             _getPropertyStates( (const PropertyMapEntry**)pEntries, aStates.getArray() );
 260
 261         delete [] pEntries;
 262
 263         if( bUnknown )
 264             throw UnknownPropertyException();
 265     }
 266
 267     return aStates;
 268 }
 269
 270 void SAL_CALL PropertySetHelper::setPropertyToDefault( const ::rtl::OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
 271 {
 272     PropertyMapEntry *pEntry  = mp->find( PropertyName );
 273     if( NULL == pEntry )
 274         throw UnknownPropertyException();
 275
 276     _setPropertyToDefault( pEntry );
 277 }
 278
 279 Any SAL_CALL PropertySetHelper::getPropertyDefault( const ::rtl::OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
 280 {
 281     PropertyMapEntry* pEntry = mp->find( aPropertyName );
 282     if( NULL == pEntry )
 283         throw UnknownPropertyException();
 284
 285     return _getPropertyDefault( pEntry );
 286 }
 287
 288 void PropertySetHelper::_getPropertyStates( const utl::PropertyMapEntry** /*ppEntries*/, PropertyState* /*pStates*/ ) throw(UnknownPropertyException )
 289 {
 290     DBG_ERROR( "you have to implement this yourself!" );
 291 }
 292
 293 void PropertySetHelper::_setPropertyToDefault( const utl::PropertyMapEntry* /*pEntry*/ )  throw(UnknownPropertyException )
 294 {
 295     DBG_ERROR( "you have to implement this yourself!" );
 296 }
 297
 298 Any PropertySetHelper::_getPropertyDefault( const utl::PropertyMapEntry* /*pEntry*/ ) throw(UnknownPropertyException, WrappedTargetException )
 299 {
 300     DBG_ERROR( "you have to implement this yourself!" );
 301
 302     Any aAny;
 303     return aAny;
 304 }