svx/source/unodraw/UnoNameItemTable.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
  21 #include <set>
  22
  23 #include <svl/itempool.hxx>
  24 #include <svl/itemset.hxx>
  25 #include <comphelper/profilezone.hxx>
  26 #include <comphelper/sequence.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28
  29 #include <svx/svdmodel.hxx>
  30 #include "UnoNameItemTable.hxx"
  31 #include <vcl/svapp.hxx>
  32
  33 #include <svx/unoapi.hxx>
  34 #include <memory>
  35
  36 using namespace ::com::sun::star;
  37 using namespace ::cppu;
  38
  39 namespace
  40 {
  41     // We need to override operator== here and specifically bypass the assert
  42     // in SfxPoolItem::operator== in order to make the GetItemSurrogates call
  43     // and comparing it's results in SvxUnoNameItemTable::hasByName safe.
  44     class SampleItem : public NameOrIndex
  45     {
  46     public:
  47         SampleItem(sal_uInt16 nWhich, const OUString& rName) : NameOrIndex(TypedWhichId<NameOrIndex>(nWhich), rName, SfxItemType::NameOrIndexType) {}
  48
  49         bool operator==(const SfxPoolItem& rCmp) const
  50         {
  51             assert(dynamic_cast<const NameOrIndex*>(&rCmp) && "comparing different pool item subclasses");
  52             auto const & rOther = static_cast<const NameOrIndex&>(rCmp);
  53             return GetName() == rOther.GetName() && GetPalIndex() == rOther.GetPalIndex();
  54         }
  55     };
  56
  57 }
  58
  59
  60 SvxUnoNameItemTable::SvxUnoNameItemTable( SdrModel* pModel, sal_uInt16 nWhich, sal_uInt8 nMemberId ) noexcept
  61 : mpModel( pModel ),
  62   mpModelPool( pModel ? &pModel->GetItemPool() : nullptr ),
  63   mnWhich( nWhich ), mnMemberId( nMemberId )
  64 {
  65     if( pModel )
  66         StartListening( *pModel );
  67 }
  68
  69 SvxUnoNameItemTable::~SvxUnoNameItemTable() noexcept
  70 {
  71     SolarMutexGuard aGuard;
  72
  73     if( mpModel )
  74         EndListening( *mpModel );
  75     dispose();
  76 }
  77
  78 bool SvxUnoNameItemTable::isValid( const NameOrIndex* pItem ) const
  79 {
  80     return pItem && !pItem->GetName().isEmpty();
  81 }
  82
  83 void SvxUnoNameItemTable::dispose()
  84 {
  85     maItemSetVector.clear();
  86 }
  87
  88 void SvxUnoNameItemTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) noexcept
  89 {
  90     if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
  91         return;
  92     const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
  93     if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
  94         dispose();
  95 }
  96
  97 sal_Bool SAL_CALL SvxUnoNameItemTable::supportsService( const  OUString& ServiceName )
  98 {
  99     return cppu::supportsService(this, ServiceName);
 100 }
 101
 102 void SvxUnoNameItemTable::ImplInsertByName( const OUString& aName, const uno::Any& aElement )
 103 {
 104     maItemSetVector.push_back( std::make_unique< SfxItemSet >( *mpModelPool, mnWhich, mnWhich ) );
 105
 106     std::unique_ptr<NameOrIndex> xNewItem(createItem());
 107     xNewItem->SetName(aName);
 108     xNewItem->PutValue(aElement, mnMemberId);
 109     xNewItem->SetWhich(mnWhich);
 110     maItemSetVector.back()->Put(std::move(xNewItem));
 111 }
 112
 113 // XNameContainer
 114 void SAL_CALL SvxUnoNameItemTable::insertByName( const OUString& aApiName, const uno::Any& aElement )
 115 {
 116     SolarMutexGuard aGuard;
 117     comphelper::ProfileZone aZone("SvxUnoNameItemTable::insertByName");
 118
 119     if( hasByName( aApiName ) )
 120         throw container::ElementExistException();
 121
 122     OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
 123
 124     ImplInsertByName( aName, aElement );
 125 }
 126
 127 void SAL_CALL SvxUnoNameItemTable::cancel()
 128 {
 129     SolarMutexGuard aGuard;
 130     // drop all items that are owned by this service and not the document
 131     // (i.e. they are unused)
 132     dispose();
 133 }
 134
 135 void SAL_CALL SvxUnoNameItemTable::removeByName( const OUString& aApiName )
 136 {
 137     SolarMutexGuard aGuard;
 138     comphelper::ProfileZone aZone("SvxUnoNameItemTable::removeByName");
 139
 140     OUString sName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
 141
 142     auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
 143         [&](const std::unique_ptr<SfxItemSet>& rpItem) {
 144             const NameOrIndex *pItem = static_cast<const NameOrIndex *>(&(rpItem->Get( mnWhich ) ));
 145             return sName == pItem->GetName();
 146         });
 147     if (aIter != maItemSetVector.end())
 148     {
 149         maItemSetVector.erase( aIter );
 150         return;
 151     }
 152
 153     if (!hasByName(sName))
 154         throw container::NoSuchElementException();
 155 }
 156
 157 // XNameReplace
 158 void SAL_CALL SvxUnoNameItemTable::replaceByName( const OUString& aApiName, const uno::Any& aElement )
 159 {
 160     SolarMutexGuard aGuard;
 161
 162     OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
 163
 164     auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
 165         [&](const std::unique_ptr<SfxItemSet>& rpItem) {
 166             const NameOrIndex *pItem = static_cast<const NameOrIndex *>(&(rpItem->Get( mnWhich ) ));
 167             return aName == pItem->GetName();
 168         });
 169     if (aIter != maItemSetVector.end())
 170     {
 171         std::unique_ptr<NameOrIndex> xNewItem(createItem());
 172         xNewItem->SetName(aName);
 173         if (!xNewItem->PutValue(aElement, mnMemberId) || !isValid(xNewItem.get()))
 174             throw lang::IllegalArgumentException();
 175         (*aIter)->Put(std::move(xNewItem));
 176         return;
 177     }
 178
 179     // if it is not in our own sets, modify the pool!
 180     bool bFound = false;
 181
 182     if (mpModelPool)
 183     {
 184         SampleItem aSample(mnWhich, aName);
 185         ItemSurrogates aSurrogates;
 186         mpModelPool->GetItemSurrogates(aSurrogates, mnWhich);
 187
 188         for (const SfxPoolItem* pNameOrIndex : aSurrogates)
 189             if (aSample == *pNameOrIndex)
 190                 if (isValid(static_cast<const NameOrIndex*>(pNameOrIndex)))
 191                 {
 192                     const_cast<SfxPoolItem*>(pNameOrIndex)->PutValue( aElement, mnMemberId );
 193                     bFound = true;
 194                 }
 195     }
 196
 197     if( !bFound )
 198         throw container::NoSuchElementException();
 199
 200     ImplInsertByName( aName, aElement );
 201
 202     if( !hasByName( aName ) )
 203         throw container::NoSuchElementException();
 204 }
 205
 206 // XNameAccess
 207 uno::Any SAL_CALL SvxUnoNameItemTable::getByName( const OUString& aApiName )
 208 {
 209     SolarMutexGuard aGuard;
 210     comphelper::ProfileZone aZone("SvxUnoNameItemTable::getByName");
 211
 212     OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
 213
 214     if (mpModelPool && !aName.isEmpty())
 215     {
 216         SampleItem aSample(mnWhich, aName);
 217         ItemSurrogates aSurrogates;
 218         mpModelPool->GetItemSurrogates(aSurrogates, mnWhich);
 219
 220         for (const SfxPoolItem* pFindItem : aSurrogates)
 221             if (aSample == *pFindItem)
 222                 if (isValid(static_cast<const NameOrIndex*>(pFindItem)))
 223                 {
 224                     uno::Any aAny;
 225                     pFindItem->QueryValue( aAny, mnMemberId );
 226                     return aAny;
 227                 }
 228     }
 229
 230     throw container::NoSuchElementException();
 231 }
 232
 233 uno::Sequence< OUString > SAL_CALL SvxUnoNameItemTable::getElementNames(  )
 234 {
 235     SolarMutexGuard aGuard;
 236
 237     std::set< OUString > aNameSet;
 238
 239
 240     if (mpModelPool)
 241     {
 242         ItemSurrogates aSurrogates;
 243         mpModelPool->GetItemSurrogates(aSurrogates, mnWhich);
 244         for (const SfxPoolItem* pItem : aSurrogates)
 245         {
 246             const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
 247
 248             if( !isValid( pNameOrIndex ) )
 249                 continue;
 250
 251             OUString aApiName = SvxUnogetApiNameForItem(mnWhich, pNameOrIndex->GetName());
 252             aNameSet.insert(aApiName);
 253         }
 254     }
 255
 256     return comphelper::containerToSequence(aNameSet);
 257 }
 258
 259 sal_Bool SAL_CALL SvxUnoNameItemTable::hasByName( const OUString& aApiName )
 260 {
 261     SolarMutexGuard aGuard;
 262
 263     OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
 264
 265     if (aName.isEmpty())
 266         return false;
 267
 268     if (!mpModelPool)
 269         return false;
 270
 271     SampleItem aSample(mnWhich, aName);
 272     ItemSurrogates aSurrogates;
 273     mpModelPool->GetItemSurrogates(aSurrogates, mnWhich);
 274
 275     for (const SfxPoolItem* pFindItem : aSurrogates)
 276         if (aSample == *pFindItem)
 277             if (isValid(static_cast<const NameOrIndex*>(pFindItem)))
 278                 return true;
 279     return false;
 280 }
 281
 282 sal_Bool SAL_CALL SvxUnoNameItemTable::hasElements(  )
 283 {
 284     SolarMutexGuard aGuard;
 285
 286     if (mpModelPool)
 287     {
 288         ItemSurrogates aSurrogates;
 289         mpModelPool->GetItemSurrogates(aSurrogates, mnWhich);
 290         for (const SfxPoolItem* pItem : aSurrogates)
 291         {
 292             const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
 293
 294             if( isValid( pNameOrIndex ) )
 295                 return true;
 296         }
 297     }
 298
 299     return false;
 300 }
 301
 302 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */