sd/source/ui/unoidl/unopback.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/drawing/BitmapMode.hpp>
  21 #include <vcl/svapp.hxx>
  22 #include <svl/itemset.hxx>
  23 #include <svx/svdpool.hxx>
  24 #include <cppuhelper/supportsservice.hxx>
  25 #include <svx/xflbstit.hxx>
  26 #include <svx/xflbmtit.hxx>
  27 #include <svx/svdobj.hxx>
  28 #include <svx/unoprov.hxx>
  29 #include <svx/unoshape.hxx>
  30 #include <svx/unoshprp.hxx>
  31
  32 #include "unopback.hxx"
  33 #include <drawdoc.hxx>
  34 #include <unokywds.hxx>
  35
  36 using namespace ::com::sun::star;
  37
  38 const SvxItemPropertySet* ImplGetPageBackgroundPropertySet()
  39 {
  40     static const SfxItemPropertyMapEntry aPageBackgroundPropertyMap_Impl[] =
  41     {
  42         FILL_PROPERTIES
  43         { OUString(), 0, css::uno::Type(), 0, 0 }
  44     };
  45
  46     static SvxItemPropertySet aPageBackgroundPropertySet_Impl( aPageBackgroundPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
  47     return &aPageBackgroundPropertySet_Impl;
  48 }
  49
  50 UNO3_GETIMPLEMENTATION_IMPL( SdUnoPageBackground );
  51
  52 SdUnoPageBackground::SdUnoPageBackground(
  53     SdDrawDocument* pDoc /* = NULL */,
  54     const SfxItemSet* pSet /* = NULL */)
  55 :   mpPropSet(ImplGetPageBackgroundPropertySet()),
  56     mpDoc(pDoc)
  57 {
  58     if( pDoc )
  59     {
  60         StartListening( *pDoc );
  61         mpSet = std::make_unique<SfxItemSet>( pDoc->GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{} );
  62
  63         if( pSet )
  64             mpSet->Put(*pSet);
  65     }
  66 }
  67
  68 SdUnoPageBackground::~SdUnoPageBackground() throw()
  69 {
  70     SolarMutexGuard g;
  71
  72     if( mpDoc )
  73         EndListening( *mpDoc );
  74 }
  75
  76 void SdUnoPageBackground::Notify( SfxBroadcaster&, const SfxHint& rHint )
  77 {
  78     if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
  79         return;
  80     const SdrHint* pSdrHint = static_cast<const SdrHint*>( &rHint );
  81
  82     // delete item set if document is dying because then the pool
  83     // will also die
  84     if( pSdrHint->GetKind() == SdrHintKind::ModelCleared )
  85     {
  86         mpSet.reset();
  87         mpDoc = nullptr;
  88     }
  89 }
  90
  91 void SdUnoPageBackground::fillItemSet( SdDrawDocument* pDoc, SfxItemSet& rSet ) throw()
  92 {
  93     rSet.ClearItem();
  94
  95     if( mpSet == nullptr )
  96     {
  97         StartListening( *pDoc );
  98         mpDoc = pDoc;
  99
 100         mpSet = std::make_unique<SfxItemSet>( *rSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{} );
 101
 102         if( mpPropSet->AreThereOwnUsrAnys() )
 103         {
 104             PropertyEntryVector_t aProperties = mpPropSet->getPropertyMap().getPropertyEntries();
 105
 106             for( const auto& rProp : aProperties )
 107             {
 108                 uno::Any* pAny = mpPropSet->GetUsrAnyForID( rProp.nWID );
 109                 if( pAny )
 110                 {
 111                     OUString aPropertyName( rProp.sName );
 112                     switch( rProp.nWID )
 113                     {
 114                         case XATTR_FILLFLOATTRANSPARENCE :
 115                         case XATTR_FILLGRADIENT :
 116                         {
 117                             if ( ( pAny->getValueType() == ::cppu::UnoType< css::awt::Gradient>::get() )
 118                                 && ( rProp.nMemberId == MID_FILLGRADIENT ) )
 119                             {
 120                                 setPropertyValue( aPropertyName, *pAny );
 121                             }
 122                             else if ( ( pAny->getValueType() == ::cppu::UnoType<OUString>::get() ) &&
 123                                         ( rProp.nMemberId == MID_NAME ) )
 124                             {
 125                                 setPropertyValue( aPropertyName, *pAny );
 126                             }
 127                         }
 128                         break;
 129                         case XATTR_FILLHATCH :
 130                         {
 131                             if ( ( pAny->getValueType() == ::cppu::UnoType< css::drawing::Hatch>::get() )
 132                                 && ( rProp.nMemberId == MID_FILLHATCH ) )
 133                             {
 134                                 setPropertyValue( aPropertyName, *pAny );
 135                             }
 136                             else if ( ( pAny->getValueType() == ::cppu::UnoType<OUString>::get() ) &&
 137                                         ( rProp.nMemberId == MID_NAME ) )
 138                             {
 139                                 setPropertyValue( aPropertyName, *pAny );
 140                             }
 141                         }
 142                         break;
 143                         case XATTR_FILLBITMAP :
 144                         {
 145                             if (rProp.nMemberId == MID_BITMAP &&
 146                                 (pAny->getValueType() == cppu::UnoType<css::awt::XBitmap>::get() ||
 147                                  pAny->getValueType() == cppu::UnoType<css::graphic::XGraphic>::get()))
 148                             {
 149                                 setPropertyValue( aPropertyName, *pAny );
 150                             }
 151                             else if (pAny->getValueType() == ::cppu::UnoType<OUString>::get() && rProp.nMemberId == MID_NAME)
 152                             {
 153                                 setPropertyValue( aPropertyName, *pAny );
 154                             }
 155                         }
 156                         break;
 157
 158                         default:
 159                             setPropertyValue( aPropertyName, *pAny );
 160                     }
 161                 }
 162             }
 163         }
 164     }
 165
 166     rSet.Put( *mpSet );
 167 }
 168
 169 // XServiceInfo
 170 OUString SAL_CALL SdUnoPageBackground::getImplementationName()
 171 {
 172     return OUString("SdUnoPageBackground");
 173 }
 174
 175 sal_Bool SAL_CALL SdUnoPageBackground::supportsService( const OUString& ServiceName )
 176 {
 177     return cppu::supportsService( this, ServiceName );
 178 }
 179
 180 uno::Sequence< OUString > SAL_CALL SdUnoPageBackground::getSupportedServiceNames()
 181 {
 182     uno::Sequence< OUString > aNameSequence( 2 );
 183     OUString* pStrings = aNameSequence.getArray();
 184
 185     *pStrings++ = sUNO_Service_PageBackground;
 186     *pStrings   = sUNO_Service_FillProperties;
 187
 188     return aNameSequence;
 189 }
 190
 191 // XPropertySet
 192 uno::Reference< beans::XPropertySetInfo > SAL_CALL SdUnoPageBackground::getPropertySetInfo()
 193 {
 194     return mpPropSet->getPropertySetInfo();
 195 }
 196
 197 void SAL_CALL SdUnoPageBackground::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 198 {
 199     SolarMutexGuard aGuard;
 200
 201     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
 202
 203     if( pEntry == nullptr )
 204     {
 205         throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
 206     }
 207
 208     if( mpSet )
 209     {
 210         if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
 211         {
 212             drawing::BitmapMode eMode;
 213             if( aValue >>= eMode )
 214             {
 215                 mpSet->Put( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
 216                 mpSet->Put( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
 217                 return;
 218             }
 219             throw lang::IllegalArgumentException();
 220         }
 221
 222         SfxItemPool& rPool = *mpSet->GetPool();
 223         SfxItemSet aSet( rPool, {{pEntry->nWID, pEntry->nWID}});
 224         aSet.Put( *mpSet );
 225
 226         if( !aSet.Count() )
 227             aSet.Put( rPool.GetDefaultItem( pEntry->nWID ) );
 228
 229         if( pEntry->nMemberId == MID_NAME && ( pEntry->nWID == XATTR_FILLBITMAP || pEntry->nWID == XATTR_FILLGRADIENT || pEntry->nWID == XATTR_FILLHATCH || pEntry->nWID == XATTR_FILLFLOATTRANSPARENCE ) )
 230         {
 231             OUString aName;
 232             if(!(aValue >>= aName ))
 233                 throw lang::IllegalArgumentException();
 234
 235             SvxShape::SetFillAttribute( pEntry->nWID, aName, aSet );
 236         }
 237         else
 238         {
 239             SvxItemPropertySet_setPropertyValue( pEntry, aValue, aSet );
 240         }
 241
 242         mpSet->Put( aSet );
 243     }
 244     else
 245     {
 246         if(pEntry->nWID)
 247             mpPropSet->setPropertyValue( pEntry, aValue );
 248     }
 249 }
 250
 251 uno::Any SAL_CALL SdUnoPageBackground::getPropertyValue( const OUString& PropertyName )
 252 {
 253     SolarMutexGuard aGuard;
 254
 255     uno::Any aAny;
 256     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry(PropertyName);
 257
 258     if( pEntry == nullptr )
 259     {
 260         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
 261     }
 262
 263     if( mpSet )
 264     {
 265         if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
 266         {
 267             const XFillBmpStretchItem* pStretchItem = mpSet->GetItem<XFillBmpStretchItem>(XATTR_FILLBMP_STRETCH);
 268             const XFillBmpTileItem* pTileItem = mpSet->GetItem<XFillBmpTileItem>(XATTR_FILLBMP_TILE);
 269
 270             if( pStretchItem && pTileItem )
 271             {
 272                 if( pTileItem->GetValue() )
 273                     aAny <<= drawing::BitmapMode_REPEAT;
 274                 else if( pStretchItem->GetValue() )
 275                     aAny <<= drawing::BitmapMode_STRETCH;
 276                 else
 277                     aAny <<= drawing::BitmapMode_NO_REPEAT;
 278             }
 279         }
 280         else
 281         {
 282             SfxItemPool& rPool = *mpSet->GetPool();
 283             SfxItemSet aSet( rPool, {{pEntry->nWID, pEntry->nWID}});
 284             aSet.Put( *mpSet );
 285
 286             if( !aSet.Count() )
 287                 aSet.Put( rPool.GetDefaultItem( pEntry->nWID ) );
 288
 289             // get value from ItemSet
 290             aAny = SvxItemPropertySet_getPropertyValue( pEntry, aSet );
 291         }
 292     }
 293     else
 294     {
 295         if(pEntry->nWID)
 296             aAny = mpPropSet->getPropertyValue( pEntry );
 297     }
 298     return aAny;
 299 }
 300
 301 void SAL_CALL SdUnoPageBackground::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >&  ) {}
 302 void SAL_CALL SdUnoPageBackground::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >&  ) {}
 303 void SAL_CALL SdUnoPageBackground::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >&  ) {}
 304 void SAL_CALL SdUnoPageBackground::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >&  ) {}
 305
 306 // XPropertyState
 307 beans::PropertyState SAL_CALL SdUnoPageBackground::getPropertyState( const OUString& PropertyName )
 308 {
 309     SolarMutexGuard aGuard;
 310
 311     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry(PropertyName);
 312
 313     if( pEntry == nullptr )
 314         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
 315
 316     if( mpSet )
 317     {
 318         if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
 319         {
 320             if( mpSet->GetItemState( XATTR_FILLBMP_STRETCH, false ) == SfxItemState::SET ||
 321                 mpSet->GetItemState( XATTR_FILLBMP_TILE, false ) == SfxItemState::SET )
 322             {
 323                 return beans::PropertyState_DIRECT_VALUE;
 324             }
 325             else
 326             {
 327                 return beans::PropertyState_AMBIGUOUS_VALUE;
 328             }
 329         }
 330
 331         switch( mpSet->GetItemState( pEntry->nWID, false ) )
 332         {
 333         case SfxItemState::READONLY:
 334         case SfxItemState::SET:
 335             return beans::PropertyState_DIRECT_VALUE;
 336         case SfxItemState::DEFAULT:
 337             return beans::PropertyState_DEFAULT_VALUE;
 338         default:
 339 //      case SfxItemState::DONTCARE:
 340 //      case SfxItemState::DISABLED:
 341             return beans::PropertyState_AMBIGUOUS_VALUE;
 342         }
 343     }
 344     else
 345     {
 346         if( nullptr == mpPropSet->GetUsrAnyForID(pEntry->nWID) )
 347             return beans::PropertyState_DEFAULT_VALUE;
 348         else
 349             return beans::PropertyState_DIRECT_VALUE;
 350     }
 351 }
 352
 353 uno::Sequence< beans::PropertyState > SAL_CALL SdUnoPageBackground::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
 354 {
 355     SolarMutexGuard aGuard;
 356
 357     sal_Int32 nCount = aPropertyName.getLength();
 358     const OUString* pNames = aPropertyName.getConstArray();
 359
 360     uno::Sequence< beans::PropertyState > aPropertyStateSequence( nCount );
 361     beans::PropertyState* pState = aPropertyStateSequence.getArray();
 362
 363     while( nCount-- )
 364         *pState++ = getPropertyState( *pNames++ );
 365
 366     return aPropertyStateSequence;
 367 }
 368
 369 void SAL_CALL SdUnoPageBackground::setPropertyToDefault( const OUString& PropertyName )
 370 {
 371     SolarMutexGuard aGuard;
 372
 373     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry(PropertyName);
 374
 375     if( pEntry == nullptr )
 376         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
 377
 378     if( mpSet )
 379     {
 380         if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
 381         {
 382             mpSet->ClearItem( XATTR_FILLBMP_STRETCH );
 383             mpSet->ClearItem( XATTR_FILLBMP_TILE );
 384         }
 385         else
 386         {
 387             mpSet->ClearItem( pEntry->nWID );
 388         }
 389     }
 390 }
 391
 392 uno::Any SAL_CALL SdUnoPageBackground::getPropertyDefault( const OUString& aPropertyName )
 393 {
 394     SolarMutexGuard aGuard;
 395
 396     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry(aPropertyName);
 397     if( pEntry == nullptr || mpSet == nullptr )
 398         throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
 399
 400     uno::Any aAny;
 401     if (pEntry->nWID == OWN_ATTR_FILLBMP_MODE)
 402     {
 403         aAny <<= drawing::BitmapMode_REPEAT;
 404     }
 405     else
 406     {
 407         SfxItemPool& rPool = *mpSet->GetPool();
 408         SfxItemSet aSet(rPool, { { pEntry->nWID, pEntry->nWID } });
 409         aSet.Put(rPool.GetDefaultItem(pEntry->nWID));
 410
 411         aAny = SvxItemPropertySet_getPropertyValue(pEntry, aSet);
 412     }
 413     return aAny;
 414 }
 415
 416 /** this is used because our property map is not sorted yet */
 417 const SfxItemPropertySimpleEntry* SdUnoPageBackground::getPropertyMapEntry( const OUString& rPropertyName ) const throw()
 418 {
 419     return mpPropSet->getPropertyMap().getByName(rPropertyName);
 420 }
 421
 422 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */