svx/source/unodraw/unopool.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/lang/XServiceInfo.hpp>
  21 #include <com/sun/star/beans/PropertyState.hpp>
  22
  23 #include <comphelper/propertysetinfo.hxx>
  24 #include <comphelper/servicehelper.hxx>
  25 #include <osl/mutex.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include "svx/unopool.hxx"
  28 #include <svx/svdmodel.hxx>
  29 #include <svx/svdpool.hxx>
  30 #include <svx/unoprov.hxx>
  31 #include <svx/svdobj.hxx>
  32 #include <svx/unoshprp.hxx>
  33 #include <svx/xflbstit.hxx>
  34 #include <svx/xflbmtit.hxx>
  35 #include <svx/unopage.hxx>
  36 #include <svx/svdetc.hxx>
  37 #include <editeng/editeng.hxx>
  38
  39 #include "svx/unoapi.hxx"
  40 #include <memory>
  41
  42 using namespace ::com::sun::star;
  43 using namespace ::rtl;
  44 using namespace ::cppu;
  45
  46 SvxUnoDrawPool::SvxUnoDrawPool( SdrModel* pModel, sal_Int32 nServiceId ) throw()
  47 : PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( nServiceId ) ), mpModel( pModel )
  48 {
  49     init();
  50 }
  51
  52 /* deprecated */
  53 SvxUnoDrawPool::SvxUnoDrawPool( SdrModel* pModel ) throw()
  54 : PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS ) ), mpModel( pModel )
  55 {
  56     init();
  57 }
  58
  59 SvxUnoDrawPool::~SvxUnoDrawPool() throw()
  60 {
  61     if (mpDefaultsPool)
  62     {
  63         SfxItemPool* pOutlPool = mpDefaultsPool->GetSecondaryPool();
  64         SfxItemPool::Free(mpDefaultsPool);
  65         SfxItemPool::Free(pOutlPool);
  66     }
  67 }
  68
  69 void SvxUnoDrawPool::init()
  70 {
  71     mpDefaultsPool = new SdrItemPool();
  72     SfxItemPool* pOutlPool=EditEngine::CreatePool();
  73     mpDefaultsPool->SetSecondaryPool(pOutlPool);
  74
  75     SdrModel::SetTextDefaults( mpDefaultsPool, SdrEngineDefaults::GetFontHeight() );
  76     mpDefaultsPool->SetDefaultMetric((SfxMapUnit)SdrEngineDefaults::GetMapUnit());
  77     mpDefaultsPool->FreezeIdRanges();
  78 }
  79
  80 SfxItemPool* SvxUnoDrawPool::getModelPool( sal_Bool bReadOnly ) throw()
  81 {
  82     if( mpModel )
  83     {
  84         return &mpModel->GetItemPool();
  85     }
  86     else
  87     {
  88         if( bReadOnly )
  89             return mpDefaultsPool;
  90         else
  91             return NULL;
  92     }
  93 }
  94
  95 void SvxUnoDrawPool::getAny( SfxItemPool* pPool, const comphelper::PropertyMapEntry* pEntry, uno::Any& rValue )
  96     throw(beans::UnknownPropertyException)
  97 {
  98     switch( pEntry->mnHandle )
  99     {
 100     case OWN_ATTR_FILLBMP_MODE:
 101         {
 102             XFillBmpStretchItem* pStretchItem = (XFillBmpStretchItem*)&pPool->GetDefaultItem(XATTR_FILLBMP_STRETCH);
 103             XFillBmpTileItem* pTileItem = (XFillBmpTileItem*)&pPool->GetDefaultItem(XATTR_FILLBMP_TILE);
 104             if( pTileItem && pTileItem->GetValue() )
 105             {
 106                 rValue <<= drawing::BitmapMode_REPEAT;
 107             }
 108             else if( pStretchItem && pStretchItem->GetValue() )
 109             {
 110                 rValue <<= drawing::BitmapMode_STRETCH;
 111             }
 112             else
 113             {
 114                 rValue <<= drawing::BitmapMode_NO_REPEAT;
 115             }
 116             break;
 117         }
 118     default:
 119         {
 120             const SfxMapUnit eMapUnit = pPool ? pPool->GetMetric((sal_uInt16)pEntry->mnHandle) : SFX_MAPUNIT_100TH_MM;
 121
 122             sal_uInt8 nMemberId = pEntry->mnMemberId & (~SFX_METRIC_ITEM);
 123             if( eMapUnit == SFX_MAPUNIT_100TH_MM )
 124                 nMemberId &= (~CONVERT_TWIPS);
 125
 126             // DVO, OD 10.10.2003 #i18732#
 127             // Assure, that ID is a Which-ID (it could be a Slot-ID.)
 128             // Thus, convert handle to Which-ID.
 129             pPool->GetDefaultItem( pPool->GetWhich( (sal_uInt16)pEntry->mnHandle ) ).QueryValue( rValue, nMemberId );
 130         }
 131     }
 132
 133
 134     // check for needed metric translation
 135     const SfxMapUnit eMapUnit = pPool->GetMetric((sal_uInt16)pEntry->mnHandle);
 136     if(pEntry->mnMemberId & SFX_METRIC_ITEM && eMapUnit != SFX_MAPUNIT_100TH_MM)
 137     {
 138         SvxUnoConvertToMM( eMapUnit, rValue );
 139     }
 140     // convert int32 to correct enum type if needed
 141     else if ( pEntry->mpType->getTypeClass() == uno::TypeClass_ENUM && rValue.getValueType() == ::getCppuType((const sal_Int32*)0) )
 142     {
 143         sal_Int32 nEnum;
 144         rValue >>= nEnum;
 145
 146         rValue.setValue( &nEnum, *pEntry->mpType );
 147     }
 148 }
 149
 150 void SvxUnoDrawPool::putAny( SfxItemPool* pPool, const comphelper::PropertyMapEntry* pEntry, const uno::Any& rValue )
 151     throw(beans::UnknownPropertyException, lang::IllegalArgumentException)
 152 {
 153     uno::Any aValue( rValue );
 154
 155     const SfxMapUnit eMapUnit = pPool->GetMetric((sal_uInt16)pEntry->mnHandle);
 156     if(pEntry->mnMemberId & SFX_METRIC_ITEM && eMapUnit != SFX_MAPUNIT_100TH_MM)
 157     {
 158         SvxUnoConvertFromMM( eMapUnit, aValue );
 159     }
 160
 161     // DVO, OD 10.10.2003 #i18732#
 162     // Assure, that ID is a Which-ID (it could be a Slot-ID.)
 163     // Thus, convert handle to Which-ID.
 164     const sal_uInt16 nWhich = pPool->GetWhich( (sal_uInt16)pEntry->mnHandle );
 165     switch( nWhich )
 166     {
 167         case OWN_ATTR_FILLBMP_MODE:
 168             do
 169             {
 170                 drawing::BitmapMode eMode;
 171                 if(!(aValue >>= eMode) )
 172                 {
 173                     sal_Int32 nMode = 0;
 174                     if(!(aValue >>= nMode))
 175                         throw lang::IllegalArgumentException();
 176
 177                     eMode = (drawing::BitmapMode)nMode;
 178                 }
 179
 180                 pPool->SetPoolDefaultItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
 181                 pPool->SetPoolDefaultItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
 182                 return;
 183             }
 184             while(0);
 185
 186     default:
 187         {
 188             ::std::auto_ptr<SfxPoolItem> pNewItem( pPool->GetDefaultItem( nWhich ).Clone() );
 189             sal_uInt8 nMemberId = pEntry->mnMemberId & (~SFX_METRIC_ITEM);
 190             if( !pPool || (pPool->GetMetric(nWhich) == SFX_MAPUNIT_100TH_MM) )
 191                 nMemberId &= (~CONVERT_TWIPS);
 192
 193             if( !pNewItem->PutValue( aValue, nMemberId ) )
 194                 throw lang::IllegalArgumentException();
 195
 196             pPool->SetPoolDefaultItem( *pNewItem );
 197         }
 198     }
 199 }
 200
 201 void SvxUnoDrawPool::_setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const uno::Any* pValues )
 202     throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException )
 203 {
 204     SolarMutexGuard aGuard;
 205
 206     SfxItemPool* pPool = getModelPool( sal_False );
 207
 208     DBG_ASSERT( pPool, "I need a SfxItemPool!" );
 209     if( NULL == pPool )
 210         throw beans::UnknownPropertyException();
 211
 212     while( *ppEntries )
 213         putAny( pPool, *ppEntries++, *pValues++ );
 214 }
 215
 216 void SvxUnoDrawPool::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValue )
 217     throw(beans::UnknownPropertyException, lang::WrappedTargetException )
 218 {
 219     SolarMutexGuard aGuard;
 220
 221     SfxItemPool* pPool = getModelPool( sal_True );
 222
 223     DBG_ASSERT( pPool, "I need a SfxItemPool!" );
 224     if( NULL == pPool )
 225         throw beans::UnknownPropertyException();
 226
 227     while( *ppEntries )
 228         getAny( pPool, *ppEntries++, *pValue++ );
 229 }
 230
 231 void SvxUnoDrawPool::_getPropertyStates( const comphelper::PropertyMapEntry** ppEntries, beans::PropertyState* pStates )
 232     throw(beans::UnknownPropertyException )
 233 {
 234     SolarMutexGuard aGuard;
 235
 236     SfxItemPool* pPool = getModelPool( sal_True );
 237
 238     if( pPool && pPool != mpDefaultsPool )
 239     {
 240         while( *ppEntries )
 241         {
 242             // OD 13.10.2003 #i18732#
 243             // Assure, that ID is a Which-ID (it could be a Slot-ID.)
 244             // Thus, convert handle to Which-ID.
 245             const sal_uInt16 nWhich = pPool->GetWhich( ((sal_uInt16)(*ppEntries)->mnHandle) );
 246
 247             switch( nWhich )
 248             {
 249             case OWN_ATTR_FILLBMP_MODE:
 250                 {
 251                     // use method <IsStaticDefaultItem(..)> instead of using
 252                     // probably incompatible item pool <mpDefaultPool>.
 253                     if ( IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_STRETCH )) ) ||
 254                          IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_TILE )) ) )
 255                     {
 256                         *pStates = beans::PropertyState_DEFAULT_VALUE;
 257                     }
 258                     else
 259                     {
 260                         *pStates = beans::PropertyState_DIRECT_VALUE;
 261                     }
 262                 }
 263                 break;
 264             default:
 265                 // OD 13.10.2003 #i18732# - correction:
 266                 // use method <IsStaticDefaultItem(..)> instead of using probably
 267                 // incompatible item pool <mpDefaultPool>.
 268                 const SfxPoolItem& r1 = pPool->GetDefaultItem( nWhich );
 269                 //const SfxPoolItem& r2 = mpDefaultPool->GetDefaultItem( nWhich );
 270
 271                 if ( IsStaticDefaultItem( &r1 ) )
 272                 {
 273                     *pStates = beans::PropertyState_DEFAULT_VALUE;
 274                 }
 275                 else
 276                 {
 277                     *pStates = beans::PropertyState_DIRECT_VALUE;
 278                 }
 279             }
 280
 281             pStates++;
 282             ppEntries++;
 283         }
 284     }
 285     else
 286     {
 287         // as long as we have no model, all properties are default
 288         while( *ppEntries++ )
 289             *pStates++ = beans::PropertyState_DEFAULT_VALUE;
 290         return;
 291     }
 292 }
 293
 294 void SvxUnoDrawPool::_setPropertyToDefault( const comphelper::PropertyMapEntry* pEntry )
 295     throw(beans::UnknownPropertyException )
 296 {
 297     SolarMutexGuard aGuard;
 298
 299     SfxItemPool* pPool = getModelPool( sal_True );
 300
 301     // OD 10.10.2003 #i18732#
 302     // Assure, that ID is a Which-ID (it could be a Slot-ID.)
 303     // Thus, convert handle to Which-ID.
 304     const sal_uInt16 nWhich = pPool->GetWhich( (sal_uInt16)pEntry->mnHandle );
 305     if ( pPool && pPool != mpDefaultsPool )
 306     {
 307         // OD 13.10.2003 #i18732# - use method <ResetPoolDefaultItem(..)>
 308         // instead of using probably incompatible item pool <mpDefaultsPool>.
 309         pPool->ResetPoolDefaultItem( nWhich );
 310     }
 311 }
 312
 313 uno::Any SvxUnoDrawPool::_getPropertyDefault( const comphelper::PropertyMapEntry* pEntry )
 314     throw(beans::UnknownPropertyException, lang::WrappedTargetException )
 315 {
 316     SolarMutexGuard aGuard;
 317
 318     // OD 13.10.2003 #i18732# - use method <GetPoolDefaultItem(..)> instead of
 319     // using probably incompatible item pool <mpDefaultsPool>
 320     uno::Any aAny;
 321     SfxItemPool* pPool = getModelPool( sal_True );
 322     const sal_uInt16 nWhich = pPool->GetWhich( (sal_uInt16)pEntry->mnHandle );
 323     const SfxPoolItem *pItem = pPool->GetPoolDefaultItem ( nWhich );
 324     pItem->QueryValue( aAny, pEntry->mnMemberId );
 325
 326     return aAny;
 327 }
 328
 329 // XInterface
 330
 331 uno::Any SAL_CALL SvxUnoDrawPool::queryInterface( const uno::Type & rType )
 332     throw( uno::RuntimeException )
 333 {
 334     return OWeakAggObject::queryInterface( rType );
 335 }
 336
 337 uno::Any SAL_CALL SvxUnoDrawPool::queryAggregation( const uno::Type & rType )
 338     throw(uno::RuntimeException)
 339 {
 340     uno::Any aAny;
 341
 342     if( rType == ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0) )
 343         aAny <<= uno::Reference< lang::XServiceInfo >(this);
 344     else if( rType == ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0) )
 345         aAny <<= uno::Reference< lang::XTypeProvider >(this);
 346     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertySet >*)0) )
 347         aAny <<= uno::Reference< beans::XPropertySet >(this);
 348     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertyState >*)0) )
 349         aAny <<= uno::Reference< beans::XPropertyState >(this);
 350     else if( rType == ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0) )
 351         aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
 352     else
 353         aAny <<= OWeakAggObject::queryAggregation( rType );
 354
 355     return aAny;
 356 }
 357
 358 void SAL_CALL SvxUnoDrawPool::acquire() throw ( )
 359 {
 360     OWeakAggObject::acquire();
 361 }
 362
 363 void SAL_CALL SvxUnoDrawPool::release() throw ( )
 364 {
 365     OWeakAggObject::release();
 366 }
 367
 368 uno::Sequence< uno::Type > SAL_CALL SvxUnoDrawPool::getTypes()
 369     throw (uno::RuntimeException)
 370 {
 371     uno::Sequence< uno::Type > aTypes( 6 );
 372     uno::Type* pTypes = aTypes.getArray();
 373
 374     *pTypes++ = ::getCppuType((const uno::Reference< uno::XAggregation>*)0);
 375     *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo>*)0);
 376     *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider>*)0);
 377     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet>*)0);
 378     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState>*)0);
 379     *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet>*)0);
 380
 381     return aTypes;
 382 }
 383
 384 namespace
 385 {
 386     class theSvxUnoDrawPoolImplementationId : public rtl::Static< UnoTunnelIdInit, theSvxUnoDrawPoolImplementationId > {};
 387 }
 388
 389 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoDrawPool::getImplementationId()
 390     throw (uno::RuntimeException)
 391 {
 392     return theSvxUnoDrawPoolImplementationId::get().getSeq();
 393 }
 394
 395 // XServiceInfo
 396
 397 sal_Bool SAL_CALL SvxUnoDrawPool::supportsService( const  OUString& ServiceName ) throw(uno::RuntimeException)
 398 {
 399     uno::Sequence< OUString > aSNL( getSupportedServiceNames() );
 400     const OUString * pArray = aSNL.getConstArray();
 401
 402     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 403         if( pArray[i] == ServiceName )
 404             return sal_True;
 405
 406     return sal_False;
 407 }
 408
 409 OUString SAL_CALL SvxUnoDrawPool::getImplementationName() throw( uno::RuntimeException )
 410 {
 411     return OUString("SvxUnoDrawPool");
 412 }
 413
 414 uno::Sequence< OUString > SAL_CALL SvxUnoDrawPool::getSupportedServiceNames(  )
 415     throw( uno::RuntimeException )
 416 {
 417     uno::Sequence< OUString > aSNS( 1 );
 418     aSNS.getArray()[0] = OUString("com.sun.star.drawing.Defaults" );
 419     return aSNS;
 420 }
 421
 422 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */