svtools/source/items1/itemprop.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: itemprop.cxx,v $
  10  * $Revision: 1.9 $
  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_svtools.hxx"
  33
  34 #include <svtools/itemprop.hxx>
  35 #include <svtools/itempool.hxx>
  36 #include <svtools/itemset.hxx>
  37 #include <com/sun/star/beans/PropertyAttribute.hpp>
  38 #include <hash_map>
  39 /*************************************************************************
  40     UNO III Implementation
  41 *************************************************************************/
  42 using namespace com::sun::star;
  43 using namespace com::sun::star::beans;
  44 using namespace com::sun::star::lang;
  45 using namespace com::sun::star::uno;
  46 using namespace ::rtl;
  47 /*-- 16.02.2009 10:03:55---------------------------------------------------
  48
  49   -----------------------------------------------------------------------*/
  50
  51 struct equalOUString
  52 {
  53   bool operator()(const ::rtl::OUString& r1, const ::rtl::OUString&  r2) const
  54   {
  55     return r1.equals( r2 );
  56   }
  57 };
  58
  59 typedef ::std::hash_map< ::rtl::OUString,
  60                                  SfxItemPropertySimpleEntry,
  61                                  ::rtl::OUStringHash,
  62                                  equalOUString > SfxItemPropertyHashMap_t;
  63
  64 class SfxItemPropertyMap_Impl : public SfxItemPropertyHashMap_t
  65 {
  66 public:
  67     mutable uno::Sequence< beans::Property > m_aPropSeq;
  68
  69     SfxItemPropertyMap_Impl(){}
  70     SfxItemPropertyMap_Impl( const SfxItemPropertyMap_Impl* pSource );
  71 };
  72 SfxItemPropertyMap_Impl::SfxItemPropertyMap_Impl( const SfxItemPropertyMap_Impl* pSource )
  73 {
  74     this->SfxItemPropertyHashMap_t::operator=( *pSource );
  75     m_aPropSeq = pSource->m_aPropSeq;
  76 }
  77
  78 /*-- 16.02.2009 10:03:51---------------------------------------------------
  79
  80   -----------------------------------------------------------------------*/
  81 SfxItemPropertyMap::SfxItemPropertyMap( const SfxItemPropertyMapEntry* pEntries ) :
  82     m_pImpl( new SfxItemPropertyMap_Impl )
  83 {
  84     while( pEntries->pName )
  85     {
  86         ::rtl::OUString sEntry(pEntries->pName, pEntries->nNameLen, RTL_TEXTENCODING_ASCII_US );
  87         (*m_pImpl) [ sEntry ] = pEntries;
  88         ++pEntries;
  89     }
  90 }
  91 /*-- 16.02.2009 12:46:41---------------------------------------------------
  92
  93   -----------------------------------------------------------------------*/
  94 SfxItemPropertyMap::SfxItemPropertyMap( const SfxItemPropertyMap* pSource ) :
  95     m_pImpl( new SfxItemPropertyMap_Impl( pSource->m_pImpl ) )
  96 {
  97 }
  98 /*-- 16.02.2009 10:03:51---------------------------------------------------
  99
 100   -----------------------------------------------------------------------*/
 101 SfxItemPropertyMap::~SfxItemPropertyMap()
 102 {
 103     delete m_pImpl;
 104 }
 105 /*-- 16.02.2009 10:03:51---------------------------------------------------
 106
 107   -----------------------------------------------------------------------*/
 108 const SfxItemPropertySimpleEntry* SfxItemPropertyMap::getByName( const ::rtl::OUString &rName ) const
 109 {
 110     SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
 111     if( aIter == m_pImpl->end() )
 112         return 0;
 113     return &aIter->second;
 114 }
 115
 116 /*-- 16.02.2009 10:44:24---------------------------------------------------
 117
 118   -----------------------------------------------------------------------*/
 119 uno::Sequence<beans::Property> SfxItemPropertyMap::getProperties() const
 120 {
 121     if( !m_pImpl->m_aPropSeq.getLength() )
 122     {
 123         m_pImpl->m_aPropSeq.realloc( m_pImpl->size() );
 124         beans::Property* pPropArray = m_pImpl->m_aPropSeq.getArray();
 125         sal_uInt32 n = 0;
 126         SfxItemPropertyHashMap_t::const_iterator aIt = m_pImpl->begin();
 127         while( aIt != m_pImpl->end() )
 128         //for ( const SfxItemPropertyMap *pMap = _pMap; pMap->pName; ++pMap )
 129         {
 130             const SfxItemPropertySimpleEntry* pEntry = &(*aIt).second;
 131             pPropArray[n].Name = (*aIt).first;
 132             pPropArray[n].Handle = pEntry->nWID;
 133             if(pEntry->pType)
 134                 pPropArray[n].Type = *pEntry->pType;
 135             pPropArray[n].Attributes =
 136                 sal::static_int_cast< sal_Int16 >(pEntry->nFlags);
 137             n++;
 138             ++aIt;
 139         }
 140     }
 141
 142     return m_pImpl->m_aPropSeq;
 143 }
 144 /*-- 16.02.2009 11:04:31---------------------------------------------------
 145
 146   -----------------------------------------------------------------------*/
 147 beans::Property SfxItemPropertyMap::getPropertyByName( const ::rtl::OUString rName ) const
 148     throw( beans::UnknownPropertyException )
 149 {
 150     SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
 151     if( aIter == m_pImpl->end() )
 152         throw UnknownPropertyException();
 153     const SfxItemPropertySimpleEntry* pEntry = &aIter->second;
 154     beans::Property aProp;
 155     aProp.Name = rName;
 156     aProp.Handle = pEntry->nWID;
 157     if(pEntry->pType)
 158         aProp.Type = *pEntry->pType;
 159     aProp.Attributes = sal::static_int_cast< sal_Int16 >(pEntry->nFlags);
 160     return aProp;
 161 }
 162 /*-- 16.02.2009 11:09:16---------------------------------------------------
 163
 164   -----------------------------------------------------------------------*/
 165 sal_Bool SfxItemPropertyMap::hasPropertyByName( const ::rtl::OUString& rName ) const
 166 {
 167     SfxItemPropertyHashMap_t::const_iterator aIter = m_pImpl->find(rName);
 168     return aIter != m_pImpl->end();
 169 }
 170 /*-- 16.02.2009 11:25:14---------------------------------------------------
 171
 172   -----------------------------------------------------------------------*/
 173 void SfxItemPropertyMap::mergeProperties( const uno::Sequence< beans::Property >& rPropSeq )
 174 {
 175     const beans::Property* pPropArray = rPropSeq.getConstArray();
 176     sal_uInt32 nElements = rPropSeq.getLength();
 177     for( sal_uInt32 nElement = 0; nElement < nElements; ++nElement )
 178     {
 179         SfxItemPropertySimpleEntry aTemp(
 180             sal::static_int_cast< sal_Int16 >( pPropArray[nElement].Handle ), //nWID
 181             &pPropArray[nElement].Type, //pType
 182             pPropArray[nElement].Attributes, //nFlags
 183             0 ); //nMemberId
 184         (*m_pImpl)[pPropArray[nElement].Name] = aTemp;
 185     }
 186 }
 187 /*-- 18.02.2009 12:04:42---------------------------------------------------
 188
 189   -----------------------------------------------------------------------*/
 190 PropertyEntryVector_t SfxItemPropertyMap::getPropertyEntries() const
 191 {
 192     PropertyEntryVector_t aRet;
 193     aRet.reserve(m_pImpl->size());
 194
 195     SfxItemPropertyHashMap_t::const_iterator aIt = m_pImpl->begin();
 196     while( aIt != m_pImpl->end() )
 197     {
 198         const SfxItemPropertySimpleEntry* pEntry = &(*aIt).second;
 199         aRet.push_back( SfxItemPropertyNamedEntry( (*aIt).first, * pEntry ) );
 200         ++aIt;
 201     }
 202     return aRet;
 203 }
 204 /*-- 18.02.2009 15:11:06---------------------------------------------------
 205
 206   -----------------------------------------------------------------------*/
 207 sal_uInt32 SfxItemPropertyMap::getSize() const
 208 {
 209     return m_pImpl->size();
 210 }
 211 /*-- 16.02.2009 13:44:54---------------------------------------------------
 212
 213   -----------------------------------------------------------------------*/
 214 SfxItemPropertySet::~SfxItemPropertySet()
 215 {
 216 }
 217 /* -----------------------------21.02.00 11:26--------------------------------
 218
 219  ---------------------------------------------------------------------------*/
 220 BOOL SfxItemPropertySet::FillItem(SfxItemSet&, USHORT, BOOL) const
 221 {
 222     return FALSE;
 223 }
 224 /* -----------------------------06.06.01 12:32--------------------------------
 225
 226  ---------------------------------------------------------------------------*/
 227 void SfxItemPropertySet::getPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
 228             const SfxItemSet& rSet, Any& rAny ) const
 229                         throw(RuntimeException)
 230 {
 231     // get the SfxPoolItem
 232     const SfxPoolItem* pItem = 0;
 233     SfxItemState eState = rSet.GetItemState( rEntry.nWID, TRUE, &pItem );
 234     if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rEntry.nWID )
 235         pItem = &rSet.GetPool()->GetDefaultItem(rEntry.nWID);
 236     // return item values as uno::Any
 237     if(eState >= SFX_ITEM_DEFAULT && pItem)
 238     {
 239         pItem->QueryValue( rAny, rEntry.nMemberId );
 240     }
 241     else
 242     {
 243         SfxItemSet aSet(*rSet.GetPool(), rEntry.nWID, rEntry.nWID);
 244         if(FillItem(aSet, rEntry.nWID, TRUE))
 245         {
 246             const SfxPoolItem& rItem = aSet.Get(rEntry.nWID);
 247             rItem.QueryValue( rAny, rEntry.nMemberId );
 248         }
 249         else if(0 == (rEntry.nFlags & PropertyAttribute::MAYBEVOID))
 250             throw RuntimeException();
 251     }
 252
 253
 254     // convert general SfxEnumItem values to specific values
 255     if( rEntry.pType && TypeClass_ENUM == rEntry.pType->getTypeClass() &&
 256          rAny.getValueTypeClass() == TypeClass_LONG )
 257     {
 258         INT32 nTmp = *(INT32*)rAny.getValue();
 259         rAny.setValue( &nTmp, *rEntry.pType );
 260     }
 261 }
 262 /* -----------------------------06.06.01 12:32--------------------------------
 263
 264  ---------------------------------------------------------------------------*/
 265 void SfxItemPropertySet::getPropertyValue( const OUString &rName,
 266             const SfxItemSet& rSet, Any& rAny ) const
 267                         throw(RuntimeException, UnknownPropertyException)
 268 {
 269     // detect which-id
 270     const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
 271     if ( !pEntry )
 272         throw UnknownPropertyException();
 273     getPropertyValue( *pEntry,rSet, rAny );
 274 }
 275 /* -----------------------------21.02.00 11:26--------------------------------
 276
 277  ---------------------------------------------------------------------------*/
 278 Any SfxItemPropertySet::getPropertyValue( const OUString &rName,
 279             const SfxItemSet& rSet ) const
 280                         throw(RuntimeException, UnknownPropertyException)
 281 {
 282     Any aVal;
 283     getPropertyValue( rName,rSet, aVal );
 284     return aVal;
 285 }
 286 /* -----------------------------15.11.00 14:46--------------------------------
 287
 288  ---------------------------------------------------------------------------*/
 289 void SfxItemPropertySet::setPropertyValue( const SfxItemPropertySimpleEntry& rEntry,
 290                                             const Any& aVal,
 291                                             SfxItemSet& rSet ) const
 292                                             throw(RuntimeException,
 293                                                     IllegalArgumentException)
 294 {
 295     // get the SfxPoolItem
 296     const SfxPoolItem* pItem = 0;
 297     SfxPoolItem *pNewItem = 0;
 298     SfxItemState eState = rSet.GetItemState( rEntry.nWID, TRUE, &pItem );
 299     if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > rEntry.nWID )
 300         pItem = &rSet.GetPool()->GetDefaultItem(rEntry.nWID);
 301     //maybe there's another way to find an Item
 302     if(eState < SFX_ITEM_DEFAULT)
 303     {
 304         SfxItemSet aSet(*rSet.GetPool(), rEntry.nWID, rEntry.nWID);
 305         if(FillItem(aSet, rEntry.nWID, FALSE))
 306         {
 307             const SfxPoolItem &rItem = aSet.Get(rEntry.nWID);
 308             pNewItem = rItem.Clone();
 309         }
 310     }
 311     if(!pNewItem && pItem)
 312     {
 313         pNewItem = pItem->Clone();
 314     }
 315     if(pNewItem)
 316     {
 317         if( !pNewItem->PutValue( aVal, rEntry.nMemberId ) )
 318         {
 319             DELETEZ(pNewItem);
 320             throw IllegalArgumentException();
 321         }
 322         // apply new item
 323         rSet.Put( *pNewItem, rEntry.nWID );
 324         delete pNewItem;
 325     }
 326 }
 327 /* -----------------------------21.02.00 11:26--------------------------------
 328
 329  ---------------------------------------------------------------------------*/
 330 void SfxItemPropertySet::setPropertyValue( const OUString &rName,
 331                                             const Any& aVal,
 332                                             SfxItemSet& rSet ) const
 333                                             throw(RuntimeException,
 334                                                     IllegalArgumentException,
 335                                                     UnknownPropertyException)
 336 {
 337     const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
 338     if ( !pEntry )
 339     {
 340         throw UnknownPropertyException();
 341     }
 342     setPropertyValue(*pEntry, aVal, rSet);
 343 }
 344 /* -----------------------------21.02.00 11:26--------------------------------
 345
 346  ---------------------------------------------------------------------------*/
 347 PropertyState SfxItemPropertySet::getPropertyState(const SfxItemPropertySimpleEntry& rEntry, const SfxItemSet& rSet) const
 348                                     throw()
 349 {
 350     PropertyState eRet = PropertyState_DIRECT_VALUE;
 351     USHORT nWhich = rEntry.nWID;
 352
 353     // item state holen
 354     SfxItemState eState = rSet.GetItemState( nWhich, FALSE );
 355     // item-Wert als UnoAny zurueckgeben
 356     if(eState == SFX_ITEM_DEFAULT)
 357         eRet = PropertyState_DEFAULT_VALUE;
 358     else if(eState < SFX_ITEM_DEFAULT)
 359         eRet = PropertyState_AMBIGUOUS_VALUE;
 360     return eRet;
 361 }
 362 PropertyState   SfxItemPropertySet::getPropertyState(
 363                                 const OUString& rName, const SfxItemSet& rSet) const
 364                                     throw(UnknownPropertyException)
 365 {
 366     PropertyState eRet = PropertyState_DIRECT_VALUE;
 367
 368     // which-id ermitteln
 369     const SfxItemPropertySimpleEntry* pEntry = m_aMap.getByName( rName );
 370     if( !pEntry || !pEntry->nWID )
 371     {
 372         throw UnknownPropertyException();
 373     }
 374     USHORT nWhich = pEntry->nWID;
 375
 376     // item holen
 377     const SfxPoolItem* pItem = 0;
 378     SfxItemState eState = rSet.GetItemState( nWhich, FALSE, &pItem );
 379     if(!pItem && nWhich != rSet.GetPool()->GetSlotId(nWhich))
 380         pItem = &rSet.GetPool()->GetDefaultItem(nWhich);
 381     // item-Wert als UnoAny zurueckgeben
 382     if(eState == SFX_ITEM_DEFAULT)
 383         eRet = PropertyState_DEFAULT_VALUE;
 384     else if(eState < SFX_ITEM_DEFAULT)
 385         eRet = PropertyState_AMBIGUOUS_VALUE;
 386     return eRet;
 387 }
 388 /* -----------------------------21.02.00 11:26--------------------------------
 389
 390  ---------------------------------------------------------------------------*/
 391 Reference<XPropertySetInfo>
 392     SfxItemPropertySet::getPropertySetInfo() const
 393 {
 394     if( !m_xInfo.is() )
 395         m_xInfo = new SfxItemPropertySetInfo( &m_aMap );
 396     return m_xInfo;
 397 }
 398 /*-- 16.02.2009 13:49:25---------------------------------------------------
 399
 400   -----------------------------------------------------------------------*/
 401 struct SfxItemPropertySetInfo_Impl
 402 {
 403     SfxItemPropertyMap*         m_pOwnMap;
 404 };
 405 /*-- 16.02.2009 13:49:24---------------------------------------------------
 406
 407   -----------------------------------------------------------------------*/
 408 SfxItemPropertySetInfo::SfxItemPropertySetInfo(const SfxItemPropertyMap *pMap ) :
 409     m_pImpl( new SfxItemPropertySetInfo_Impl )
 410 {
 411     m_pImpl->m_pOwnMap = new SfxItemPropertyMap( pMap );
 412 }
 413 /*-- 16.02.2009 13:49:25---------------------------------------------------
 414
 415   -----------------------------------------------------------------------*/
 416 SfxItemPropertySetInfo::SfxItemPropertySetInfo(const SfxItemPropertyMapEntry *pEntries ) :
 417     m_pImpl( new SfxItemPropertySetInfo_Impl )
 418 {
 419     m_pImpl->m_pOwnMap = new SfxItemPropertyMap( pEntries );
 420 }
 421 /* -----------------------------21.02.00 11:09--------------------------------
 422
 423  ---------------------------------------------------------------------------*/
 424 Sequence< Property > SAL_CALL
 425         SfxItemPropertySetInfo::getProperties(  )
 426             throw(RuntimeException)
 427 {
 428     return m_pImpl->m_pOwnMap->getProperties();
 429 }
 430 /*-- 16.02.2009 13:49:27---------------------------------------------------
 431
 432   -----------------------------------------------------------------------*/
 433 const SfxItemPropertyMap* SfxItemPropertySetInfo::getMap() const
 434 {
 435     return m_pImpl->m_pOwnMap;
 436 }
 437
 438 /*-- 16.02.2009 12:43:36---------------------------------------------------
 439
 440   -----------------------------------------------------------------------*/
 441 SfxItemPropertySetInfo::~SfxItemPropertySetInfo()
 442 {
 443     delete m_pImpl->m_pOwnMap;
 444     delete m_pImpl;
 445 }
 446 /* -----------------------------21.02.00 11:27--------------------------------
 447
 448  ---------------------------------------------------------------------------*/
 449 Property SAL_CALL
 450         SfxItemPropertySetInfo::getPropertyByName( const ::rtl::OUString& rName )
 451             throw(UnknownPropertyException, RuntimeException)
 452 {
 453     return m_pImpl->m_pOwnMap->getPropertyByName( rName );
 454 }
 455 /* -----------------------------21.02.00 11:28--------------------------------
 456
 457  ---------------------------------------------------------------------------*/
 458 sal_Bool SAL_CALL
 459         SfxItemPropertySetInfo::hasPropertyByName( const ::rtl::OUString& rName )
 460             throw(RuntimeException)
 461 {
 462     return m_pImpl->m_pOwnMap->hasPropertyByName( rName );
 463 }
 464 /* -----------------------------21.02.00 12:03--------------------------------
 465
 466  ---------------------------------------------------------------------------*/
 467 SfxExtItemPropertySetInfo::SfxExtItemPropertySetInfo(
 468                                 const SfxItemPropertyMapEntry *pMap,
 469                                 const Sequence<Property>& rPropSeq ) :
 470                 aExtMap( pMap )
 471 {
 472     aExtMap.mergeProperties( rPropSeq );
 473 }
 474 /*-- 16.02.2009 12:06:49---------------------------------------------------
 475
 476   -----------------------------------------------------------------------*/
 477 SfxExtItemPropertySetInfo::~SfxExtItemPropertySetInfo()
 478 {
 479 }
 480 /* -----------------------------21.02.00 12:03--------------------------------
 481
 482  ---------------------------------------------------------------------------*/
 483 Sequence< Property > SAL_CALL
 484         SfxExtItemPropertySetInfo::getProperties(  ) throw(RuntimeException)
 485 {
 486     return aExtMap.getProperties();
 487 }
 488 /* -----------------------------21.02.00 12:03--------------------------------
 489
 490  ---------------------------------------------------------------------------*/
 491 Property SAL_CALL
 492         SfxExtItemPropertySetInfo::getPropertyByName( const OUString& rPropertyName )
 493             throw(UnknownPropertyException, RuntimeException)
 494 {
 495     return aExtMap.getPropertyByName( rPropertyName );
 496 }
 497 /* -----------------------------21.02.00 12:03--------------------------------
 498
 499  ---------------------------------------------------------------------------*/
 500 sal_Bool SAL_CALL
 501         SfxExtItemPropertySetInfo::hasPropertyByName( const OUString& rPropertyName )
 502             throw(RuntimeException)
 503 {
 504     return aExtMap.hasPropertyByName( rPropertyName );
 505 }
 506