svx/source/unodraw/unomtabl.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 <sal/config.h>
  21
  22 #include <memory>
  23 #include <set>
  24 #include <com/sun/star/lang/XServiceInfo.hpp>
  25 #include <com/sun/star/container/XNameContainer.hpp>
  26 #include <com/sun/star/drawing/PointSequence.hpp>
  27 #include <com/sun/star/util/XCancellable.hpp>
  28
  29 #include <comphelper/sequence.hxx>
  30 #include <cppuhelper/implbase.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <svl/itempool.hxx>
  33 #include <svl/itemset.hxx>
  34 #include <svl/lstner.hxx>
  35 #include <svx/xlnedit.hxx>
  36 #include <svx/xlnstit.hxx>
  37 #include <svx/svdmodel.hxx>
  38 #include <svx/xdef.hxx>
  39
  40 #include <vector>
  41 #include <vcl/svapp.hxx>
  42
  43
  44 #include <svx/unofill.hxx>
  45
  46 #include <svx/unoapi.hxx>
  47
  48 using namespace ::com::sun::star;
  49 using namespace ::cppu;
  50
  51 typedef std::vector<std::unique_ptr<SfxItemSet>> ItemPoolVector;
  52
  53 namespace {
  54
  55 class SvxUnoMarkerTable
  56     : public WeakImplHelper<
  57         util::XCancellable,
  58         container::XNameContainer,
  59         lang::XServiceInfo>
  60     , public SfxListener
  61 {
  62 private:
  63     SdrModel*       mpModel;
  64     SfxItemPool*    mpModelPool;
  65
  66     ItemPoolVector maItemSetVector;
  67
  68 public:
  69     explicit SvxUnoMarkerTable( SdrModel* pModel ) noexcept;
  70     virtual ~SvxUnoMarkerTable() noexcept override;
  71
  72     void dispose();
  73
  74     // SfxListener
  75     virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) noexcept override;
  76
  77     void ImplInsertByName( const OUString& aName, const uno::Any& aElement );
  78
  79     // XServiceInfo
  80     virtual OUString SAL_CALL getImplementationName(  ) override;
  81     virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) override;
  82     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
  83
  84     // XCancellable
  85     virtual void SAL_CALL cancel() override;
  86
  87     // XNameContainer
  88     virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) override;
  89     virtual void SAL_CALL removeByName( const  OUString& Name ) override;
  90
  91     // XNameReplace
  92     virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) override;
  93
  94     // XNameAccess
  95     virtual uno::Any SAL_CALL getByName( const  OUString& aName ) override;
  96     virtual uno::Sequence<  OUString > SAL_CALL getElementNames(  ) override;
  97     virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) override;
  98
  99     // XElementAccess
 100     virtual uno::Type SAL_CALL getElementType(  ) override;
 101     virtual sal_Bool SAL_CALL hasElements(  ) override;
 102 };
 103
 104 }
 105
 106 SvxUnoMarkerTable::SvxUnoMarkerTable( SdrModel* pModel ) noexcept
 107 : mpModel( pModel ),
 108   mpModelPool( pModel ? &pModel->GetItemPool() : nullptr )
 109 {
 110     if( pModel )
 111         StartListening( *pModel );
 112 }
 113
 114 SvxUnoMarkerTable::~SvxUnoMarkerTable() noexcept
 115 {
 116     SolarMutexGuard aGuard;
 117
 118     if( mpModel )
 119         EndListening( *mpModel );
 120     dispose();
 121 }
 122
 123 void SvxUnoMarkerTable::dispose()
 124 {
 125     maItemSetVector.clear();
 126 }
 127
 128 // SfxListener
 129 void SvxUnoMarkerTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) noexcept
 130 {
 131     if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
 132     {
 133         const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
 134         if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
 135             dispose();
 136     }
 137 }
 138
 139 sal_Bool SAL_CALL SvxUnoMarkerTable::supportsService( const  OUString& ServiceName )
 140 {
 141     return cppu::supportsService(this, ServiceName);
 142 }
 143
 144 OUString SAL_CALL SvxUnoMarkerTable::getImplementationName()
 145 {
 146     return u"SvxUnoMarkerTable"_ustr;
 147 }
 148
 149 uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getSupportedServiceNames(  )
 150 {
 151     uno::Sequence<OUString> aSNS { u"com.sun.star.drawing.MarkerTable"_ustr };
 152     return aSNS;
 153 }
 154
 155 void SvxUnoMarkerTable::ImplInsertByName( const OUString& aName, const uno::Any& aElement )
 156 {
 157     maItemSetVector.push_back(
 158         std::make_unique<SfxItemSetFixed<XATTR_LINESTART, XATTR_LINEEND>>( *mpModelPool ));
 159     auto pInSet = maItemSetVector.back().get();
 160
 161     XLineEndItem aEndMarker(XATTR_LINEEND);
 162     aEndMarker.SetName( aName );
 163     aEndMarker.PutValue( aElement, 0 );
 164
 165     pInSet->Put( aEndMarker );
 166
 167     XLineStartItem aStartMarker(XATTR_LINESTART);
 168     aStartMarker.SetName( aName );
 169     aStartMarker.PutValue( aElement, 0 );
 170
 171     pInSet->Put( aStartMarker );
 172 }
 173
 174 // XNameContainer
 175 void SAL_CALL SvxUnoMarkerTable::insertByName( const OUString& aApiName, const uno::Any& aElement )
 176 {
 177     SolarMutexGuard aGuard;
 178
 179     if( hasByName( aApiName ) )
 180         throw container::ElementExistException();
 181
 182     OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
 183
 184     ImplInsertByName( aName, aElement );
 185 }
 186
 187 void SAL_CALL SvxUnoMarkerTable::cancel()
 188 {
 189     SolarMutexGuard aGuard;
 190     // drop all items that are owned by this service and not the document
 191     // (i.e. they are unused)
 192     dispose();
 193 }
 194
 195 void SAL_CALL SvxUnoMarkerTable::removeByName( const OUString& aApiName )
 196 {
 197     SolarMutexGuard aGuard;
 198
 199     OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
 200
 201     auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
 202         [&aName](const std::unique_ptr<SfxItemSet>& rpItem) {
 203             const NameOrIndex *pItem = &(rpItem->Get( XATTR_LINEEND ) );
 204             return pItem->GetName() == aName;
 205         });
 206     if (aIter != maItemSetVector.end())
 207     {
 208         maItemSetVector.erase( aIter );
 209         return;
 210     }
 211
 212     if( !hasByName( aName ) )
 213         throw container::NoSuchElementException();
 214 }
 215
 216 // XNameReplace
 217 void SAL_CALL SvxUnoMarkerTable::replaceByName( const OUString& aApiName, const uno::Any& aElement )
 218 {
 219     SolarMutexGuard aGuard;
 220
 221     const OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
 222
 223     auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
 224         [&aName](const std::unique_ptr<SfxItemSet>& rpItem) {
 225             const NameOrIndex *pItem = &(rpItem->Get( XATTR_LINEEND ) );
 226             return pItem->GetName() == aName;
 227         });
 228     if (aIter != maItemSetVector.end())
 229     {
 230         XLineEndItem aEndMarker(XATTR_LINEEND);
 231         aEndMarker.SetName( aName );
 232         if( !aEndMarker.PutValue( aElement, 0 ) )
 233             throw lang::IllegalArgumentException();
 234
 235         (*aIter)->Put( aEndMarker );
 236
 237         XLineStartItem aStartMarker(XATTR_LINESTART);
 238         aStartMarker.SetName( aName );
 239         aStartMarker.PutValue( aElement, 0 );
 240
 241         (*aIter)->Put( aStartMarker );
 242         return;
 243     }
 244
 245     // if it is not in our own sets, modify the pool!
 246     bool bFound = false;
 247
 248     if (mpModelPool)
 249     {
 250         mpModelPool->iterateItemSurrogates(XATTR_LINESTART, [&](SfxItemPool::SurrogateData& rData)
 251         {
 252             const NameOrIndex* pItem(static_cast<const NameOrIndex*>(&rData.getItem()));
 253             if( pItem && pItem->GetName() == aName )
 254             {
 255                 NameOrIndex* pNew(pItem->Clone(mpModelPool));
 256                 pNew->PutValue(aElement, 0);
 257                 rData.setItem(std::unique_ptr<SfxPoolItem>(pNew));
 258                 bFound = true;
 259                 return false; // interrupt callbacks
 260             }
 261             return true; // continue callbacks
 262         });
 263     }
 264
 265     if (mpModelPool)
 266     {
 267         mpModelPool->iterateItemSurrogates(XATTR_LINEEND, [&](SfxItemPool::SurrogateData& rData)
 268         {
 269             const NameOrIndex* pItem(static_cast<const NameOrIndex*>(&rData.getItem()));
 270             if( pItem && pItem->GetName() == aName )
 271             {
 272                 NameOrIndex* pNew(pItem->Clone(mpModelPool));
 273                 pNew->PutValue(aElement, 0);
 274                 rData.setItem(std::unique_ptr<SfxPoolItem>(pNew));
 275                 bFound = true;
 276                 return false; // interrupt callbacks
 277             }
 278             return true; // continue callbacks
 279         });
 280     }
 281
 282     if( !bFound )
 283         throw container::NoSuchElementException();
 284
 285     ImplInsertByName( aName, aElement );
 286 }
 287
 288 static bool getByNameFromPool( std::u16string_view rSearchName, SfxItemPool const * pPool, SfxItemType eItemType, uno::Any& rAny )
 289 {
 290     if (pPool)
 291     {
 292         ItemSurrogates aSurrogates;
 293         pPool->GetItemSurrogatesForItem(aSurrogates, eItemType);
 294         for (const SfxPoolItem* p : aSurrogates)
 295         {
 296             const NameOrIndex *pItem = static_cast<const NameOrIndex*>(p);
 297
 298             if( pItem->GetName() == rSearchName )
 299             {
 300                 pItem->QueryValue( rAny );
 301                 return true;
 302             }
 303         }
 304     }
 305
 306     return false;
 307 }
 308
 309 // XNameAccess
 310 uno::Any SAL_CALL SvxUnoMarkerTable::getByName( const OUString& aApiName )
 311 {
 312     SolarMutexGuard aGuard;
 313
 314     OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
 315
 316     uno::Any aAny;
 317
 318     if (mpModelPool && !aName.isEmpty())
 319     {
 320         do
 321         {
 322             if (getByNameFromPool(aName, mpModelPool, SfxItemType::XLineStartItemType, aAny)) // XATTR_LINESTART
 323                 break;
 324
 325             if (getByNameFromPool(aName, mpModelPool, SfxItemType::XLineEndItemType, aAny)) // XATTR_LINEEND
 326                 break;
 327
 328             throw container::NoSuchElementException();
 329         }
 330         while(false);
 331     }
 332
 333     return aAny;
 334 }
 335
 336 static void createNamesForPool( SfxItemPool const * pPool, SfxItemType eItemType, std::set< OUString >& rNameSet )
 337 {
 338     ItemSurrogates aSurrogates;
 339     pPool->GetItemSurrogatesForItem(aSurrogates, eItemType);
 340     for (const SfxPoolItem* p : aSurrogates)
 341     {
 342         const NameOrIndex* pItem = static_cast<const NameOrIndex*>(p);
 343
 344         if( pItem->GetName().isEmpty() )
 345             continue;
 346
 347         OUString aName = SvxUnogetApiNameForItem(XATTR_LINEEND, pItem->GetName());
 348         rNameSet.insert( aName );
 349     }
 350 }
 351
 352 uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getElementNames()
 353 {
 354     SolarMutexGuard aGuard;
 355
 356     std::set< OUString > aNameSet;
 357
 358     // search model pool for line starts
 359     createNamesForPool( mpModelPool, SfxItemType::XLineStartItemType, aNameSet ); // XATTR_LINESTART
 360
 361     // search model pool for line ends
 362     createNamesForPool( mpModelPool, SfxItemType::XLineEndItemType, aNameSet ); // XATTR_LINEEND
 363
 364     return comphelper::containerToSequence(aNameSet);
 365 }
 366
 367 sal_Bool SAL_CALL SvxUnoMarkerTable::hasByName( const OUString& aName )
 368 {
 369     SolarMutexGuard aGuard;
 370
 371     if( aName.isEmpty() )
 372         return false;
 373
 374     OUString aSearchName;
 375
 376     const NameOrIndex *pItem;
 377
 378     aSearchName = SvxUnogetInternalNameForItem(XATTR_LINESTART, aName);
 379     if (mpModelPool)
 380     {
 381         ItemSurrogates aSurrogates;
 382         mpModelPool->GetItemSurrogatesForItem(aSurrogates, SfxItemType::XLineStartItemType); // XATTR_LINESTART
 383         for (const SfxPoolItem* p : aSurrogates)
 384         {
 385             pItem = static_cast<const NameOrIndex*>(p);
 386             if( pItem && pItem->GetName() == aSearchName )
 387                 return true;
 388         }
 389     }
 390
 391     aSearchName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aName);
 392     if (mpModelPool)
 393     {
 394         ItemSurrogates aSurrogates;
 395         mpModelPool->GetItemSurrogatesForItem(aSurrogates, SfxItemType::XLineEndItemType); // XATTR_LINEEND
 396         for (const SfxPoolItem* p : aSurrogates)
 397         {
 398             pItem = static_cast<const NameOrIndex*>(p);
 399             if( pItem && pItem->GetName() == aSearchName )
 400                 return true;
 401         }
 402     }
 403
 404     return false;
 405 }
 406
 407 // XElementAccess
 408 uno::Type SAL_CALL SvxUnoMarkerTable::getElementType(  )
 409 {
 410     return cppu::UnoType<drawing::PointSequence>::get();
 411 }
 412
 413 sal_Bool SAL_CALL SvxUnoMarkerTable::hasElements(  )
 414 {
 415     SolarMutexGuard aGuard;
 416
 417     const NameOrIndex *pItem;
 418
 419     if (mpModelPool)
 420     {
 421         ItemSurrogates aSurrogates;
 422         mpModelPool->GetItemSurrogatesForItem(aSurrogates, SfxItemType::XLineStartItemType); // XATTR_LINESTART
 423         for (const SfxPoolItem* p : aSurrogates)
 424         {
 425             pItem = static_cast<const NameOrIndex*>(p);
 426             if( pItem && !pItem->GetName().isEmpty() )
 427                 return true;
 428         }
 429     }
 430
 431     if (mpModelPool)
 432     {
 433         ItemSurrogates aSurrogates;
 434         mpModelPool->GetItemSurrogatesForItem(aSurrogates, SfxItemType::XLineEndItemType); // XATTR_LINEEND
 435         for (const SfxPoolItem* p : aSurrogates)
 436         {
 437             pItem = static_cast<const NameOrIndex*>(p);
 438             if( pItem && !pItem->GetName().isEmpty() )
 439                 return true;
 440         }
 441     }
 442
 443     return false;
 444 }
 445
 446 /**
 447  * Create a hatchtable
 448  */
 449 uno::Reference< uno::XInterface > SvxUnoMarkerTable_createInstance( SdrModel* pModel )
 450 {
 451     return *new SvxUnoMarkerTable(pModel);
 452 }
 453
 454
 455 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */