svx/source/unodraw/unomtabl.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: unomtabl.cxx,v $
  10  * $Revision: 1.22 $
  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_svx.hxx"
  33
  34 #include <set>
  35 #include <comphelper/stl_types.hxx>
  36 #include <com/sun/star/lang/XServiceInfo.hpp>
  37 #include <com/sun/star/container/XNameContainer.hpp>
  38 #include <com/sun/star/drawing/PointSequence.hpp>
  39 #include <svtools/style.hxx>
  40
  41 #include <cppuhelper/implbase2.hxx>
  42 #include <svtools/itempool.hxx>
  43 #include <svtools/itemset.hxx>
  44 #include <svtools/lstner.hxx>
  45 #include <svx/xlnedit.hxx>
  46 #include <svx/xlnstit.hxx>
  47 #include <svx/svdmodel.hxx>
  48 #include <svx/xdef.hxx>
  49 #include <svx/xflhtit.hxx>
  50
  51 #include <vector>
  52 #include <vos/mutex.hxx>
  53 #include <vcl/svapp.hxx>
  54
  55
  56 #include "unofill.hxx"
  57
  58 #include "unoapi.hxx"
  59
  60 using namespace ::com::sun::star;
  61 using namespace ::rtl;
  62 using namespace ::cppu;
  63 using namespace ::vos;
  64
  65 typedef std::vector< SfxItemSet* > ItemPoolVector;
  66
  67 class SvxUnoMarkerTable : public WeakImplHelper2< container::XNameContainer, lang::XServiceInfo >,
  68                           public SfxListener
  69 {
  70 private:
  71     SdrModel*           mpModel;
  72     SfxItemPool*        mpModelPool;
  73
  74     ItemPoolVector maItemSetVector;
  75
  76 public:
  77     SvxUnoMarkerTable( SdrModel* pModel ) throw();
  78     virtual     ~SvxUnoMarkerTable() throw();
  79
  80     void dispose();
  81
  82     // SfxListener
  83     virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw ();
  84
  85     void SAL_CALL ImplInsertByName( const OUString& aName, const uno::Any& aElement );
  86
  87     // XServiceInfo
  88     virtual OUString SAL_CALL getImplementationName(  ) throw( uno::RuntimeException );
  89     virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) throw( uno::RuntimeException);
  90     virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) throw( uno::RuntimeException);
  91
  92     // XNameContainer
  93     virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException);
  94     virtual void SAL_CALL removeByName( const  OUString& Name ) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException);
  95
  96     // XNameReplace
  97     virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException);
  98
  99     // XNameAccess
 100     virtual uno::Any SAL_CALL getByName( const  OUString& aName ) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException);
 101     virtual uno::Sequence<  OUString > SAL_CALL getElementNames(  ) throw( uno::RuntimeException);
 102     virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) throw( uno::RuntimeException);
 103
 104     // XElementAccess
 105     virtual uno::Type SAL_CALL getElementType(  ) throw( uno::RuntimeException);
 106     virtual sal_Bool SAL_CALL hasElements(  ) throw( uno::RuntimeException);
 107 };
 108
 109 SvxUnoMarkerTable::SvxUnoMarkerTable( SdrModel* pModel ) throw()
 110 : mpModel( pModel ),
 111   mpModelPool( pModel ? &pModel->GetItemPool() : (SfxItemPool*)NULL )
 112 {
 113     if( pModel )
 114         StartListening( *pModel );
 115 }
 116
 117 SvxUnoMarkerTable::~SvxUnoMarkerTable() throw()
 118 {
 119     if( mpModel )
 120         EndListening( *mpModel );
 121     dispose();
 122 }
 123
 124 void SvxUnoMarkerTable::dispose()
 125 {
 126     ItemPoolVector::iterator aIter = maItemSetVector.begin();
 127     const ItemPoolVector::iterator aEnd = maItemSetVector.end();
 128
 129     while( aIter != aEnd )
 130     {
 131         delete (*aIter++);
 132     }
 133
 134     maItemSetVector.clear();
 135 }
 136
 137 // SfxListener
 138 void SvxUnoMarkerTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
 139 {
 140     const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
 141
 142     if( pSdrHint && HINT_MODELCLEARED == pSdrHint->GetKind() )
 143         dispose();
 144 }
 145
 146 sal_Bool SAL_CALL SvxUnoMarkerTable::supportsService( const  OUString& ServiceName ) throw(uno::RuntimeException)
 147 {
 148     uno::Sequence< OUString > aSNL( getSupportedServiceNames() );
 149     const OUString * pArray = aSNL.getConstArray();
 150
 151     for( INT32 i = 0; i < aSNL.getLength(); i++ )
 152         if( pArray[i] == ServiceName )
 153             return TRUE;
 154
 155     return FALSE;
 156 }
 157
 158 OUString SAL_CALL SvxUnoMarkerTable::getImplementationName() throw( uno::RuntimeException )
 159 {
 160     return OUString( RTL_CONSTASCII_USTRINGPARAM("SvxUnoMarkerTable") );
 161 }
 162
 163 uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getSupportedServiceNames(  )
 164     throw( uno::RuntimeException )
 165 {
 166     uno::Sequence< OUString > aSNS( 1 );
 167     aSNS.getArray()[0] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.MarkerTable" ));
 168     return aSNS;
 169 }
 170
 171 void SAL_CALL SvxUnoMarkerTable::ImplInsertByName( const OUString& aName, const uno::Any& aElement )
 172 {
 173     SfxItemSet* mpInSet = new SfxItemSet( *mpModelPool, XATTR_LINESTART, XATTR_LINEEND );
 174     maItemSetVector.push_back( mpInSet );
 175
 176     XLineEndItem aEndMarker;
 177     aEndMarker.SetName( String( aName ) );
 178     aEndMarker.PutValue( aElement );
 179
 180     mpInSet->Put( aEndMarker, XATTR_LINEEND );
 181
 182     XLineStartItem aStartMarker;
 183     aStartMarker.SetName( String( aName ) );
 184     aStartMarker.PutValue( aElement );
 185
 186     mpInSet->Put( aStartMarker, XATTR_LINESTART );
 187 }
 188
 189 // XNameContainer
 190 void SAL_CALL SvxUnoMarkerTable::insertByName( const OUString& aApiName, const uno::Any& aElement )
 191     throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException )
 192 {
 193     OGuard aGuard( Application::GetSolarMutex() );
 194
 195     if( hasByName( aApiName ) )
 196         throw container::ElementExistException();
 197
 198     String aName;
 199     SvxUnogetInternalNameForItem( XATTR_LINEEND, aApiName, aName );
 200
 201     ImplInsertByName( aName, aElement );
 202 }
 203
 204 void SAL_CALL SvxUnoMarkerTable::removeByName( const OUString& aApiName )
 205     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 206 {
 207     OGuard aGuard( Application::GetSolarMutex() );
 208
 209     // a little quickfix for 2.0 to let applications clear api
 210     // created items that are not used
 211     if( aApiName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("~clear~") ) )
 212     {
 213         dispose();
 214         return;
 215     }
 216
 217     String Name;
 218     SvxUnogetInternalNameForItem( XATTR_LINEEND, aApiName, Name );
 219
 220     ItemPoolVector::iterator aIter = maItemSetVector.begin();
 221     const ItemPoolVector::iterator aEnd = maItemSetVector.end();
 222
 223     NameOrIndex *pItem;
 224     const String aSearchName( Name );
 225
 226     while( aIter != aEnd )
 227     {
 228         pItem = (NameOrIndex *)&((*aIter)->Get( XATTR_LINEEND ) );
 229         if( pItem->GetName() == aSearchName )
 230         {
 231             delete (*aIter);
 232             maItemSetVector.erase( aIter );
 233             return;
 234         }
 235         aIter++;
 236     }
 237
 238     if( !hasByName( Name ) )
 239         throw container::NoSuchElementException();
 240 }
 241
 242 // XNameReplace
 243 void SAL_CALL SvxUnoMarkerTable::replaceByName( const OUString& aApiName, const uno::Any& aElement )
 244     throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
 245 {
 246     OGuard aGuard( Application::GetSolarMutex() );
 247
 248     String aName;
 249     SvxUnogetInternalNameForItem( XATTR_LINEEND, aApiName, aName );
 250
 251     ItemPoolVector::iterator aIter = maItemSetVector.begin();
 252     const ItemPoolVector::iterator aEnd = maItemSetVector.end();
 253
 254     NameOrIndex *pItem;
 255     const String aSearchName( aName );
 256
 257     while( aIter != aEnd )
 258     {
 259         pItem = (NameOrIndex *)&((*aIter)->Get( XATTR_LINEEND ) );
 260         if( pItem->GetName() == aSearchName )
 261         {
 262             XLineEndItem aEndMarker;
 263             aEndMarker.SetName( aSearchName );
 264             if( !aEndMarker.PutValue( aElement ) )
 265                 throw lang::IllegalArgumentException();
 266
 267             (*aIter)->Put( aEndMarker, XATTR_LINEEND );
 268
 269             XLineStartItem aStartMarker;
 270             aStartMarker.SetName( aSearchName );
 271             aStartMarker.PutValue( aElement );
 272
 273             (*aIter)->Put( aStartMarker, XATTR_LINESTART );
 274             return;
 275         }
 276         aIter++;
 277     }
 278
 279     // if it is not in our own sets, modify the pool!
 280     sal_Bool bFound = sal_False;
 281
 282     USHORT nSurrogate;
 283     const USHORT nStartCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINESTART ) : 0;
 284     for( nSurrogate = 0; nSurrogate < nStartCount; nSurrogate++ )
 285     {
 286         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINESTART, nSurrogate);
 287         if( pItem && pItem->GetName() == aSearchName )
 288         {
 289             pItem->PutValue( aElement );
 290             bFound = sal_True;
 291             break;
 292         }
 293     }
 294
 295     const USHORT nEndCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINEEND ) : 0;
 296     for( nSurrogate = 0; nSurrogate < nEndCount; nSurrogate++ )
 297     {
 298         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINEEND, nSurrogate);
 299         if( pItem && pItem->GetName() == aSearchName )
 300         {
 301             pItem->PutValue( aElement );
 302             bFound = sal_True;
 303             break;
 304         }
 305     }
 306
 307     if( bFound )
 308         ImplInsertByName( aName, aElement );
 309     else
 310         throw container::NoSuchElementException();
 311 }
 312
 313 static sal_Bool getByNameFromPool( const String& rSearchName, SfxItemPool* pPool, USHORT nWhich, uno::Any& rAny )
 314 {
 315     NameOrIndex *pItem;
 316     const sal_Int32 nSurrogateCount = pPool ? (sal_Int32)pPool->GetItemCount( nWhich ) : 0;
 317     for( sal_Int32 nSurrogate = 0; nSurrogate < nSurrogateCount; nSurrogate++ )
 318     {
 319         pItem = (NameOrIndex*)pPool->GetItem( nWhich, (USHORT)nSurrogate );
 320
 321         if( pItem && pItem->GetName() == rSearchName )
 322         {
 323             pItem->QueryValue( rAny, 0 );
 324             return sal_True;
 325         }
 326     }
 327
 328     return sal_False;
 329 }
 330
 331 // XNameAccess
 332 uno::Any SAL_CALL SvxUnoMarkerTable::getByName( const OUString& aApiName )
 333     throw( container::NoSuchElementException,  lang::WrappedTargetException, uno::RuntimeException)
 334 {
 335     OGuard aGuard( Application::GetSolarMutex() );
 336
 337     String aName;
 338     SvxUnogetInternalNameForItem( XATTR_LINEEND, aApiName, aName );
 339
 340     uno::Any aAny;
 341
 342     if( mpModelPool && aName.Len() != 0 )
 343     {
 344         do
 345         {
 346             const String aSearchName( aName );
 347             if( getByNameFromPool( aSearchName, mpModelPool, XATTR_LINESTART, aAny ) )
 348                 break;
 349
 350             if( getByNameFromPool( aSearchName, mpModelPool, XATTR_LINEEND, aAny ) )
 351                 break;
 352
 353             throw container::NoSuchElementException();
 354         }
 355         while(0);
 356     }
 357
 358     return aAny;
 359 }
 360
 361 static void createNamesForPool( SfxItemPool* pPool, USHORT nWhich, std::set< OUString, comphelper::UStringLess >& rNameSet )
 362 {
 363     const sal_Int32 nSuroCount = pPool->GetItemCount( nWhich );
 364     sal_Int32 nSurrogate;
 365
 366     NameOrIndex *pItem;
 367     OUString aName;
 368
 369     for( nSurrogate = 0; nSurrogate < nSuroCount; nSurrogate++ )
 370     {
 371         pItem = (NameOrIndex*)pPool->GetItem( nWhich, (USHORT)nSurrogate );
 372
 373         if( pItem == NULL || pItem->GetName().Len() == 0 )
 374             continue;
 375
 376         SvxUnogetApiNameForItem( XATTR_LINEEND, pItem->GetName(), aName );
 377         rNameSet.insert( aName );
 378     }
 379 }
 380
 381 uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getElementNames()
 382     throw( uno::RuntimeException )
 383 {
 384     OGuard aGuard( Application::GetSolarMutex() );
 385
 386     std::set< OUString, comphelper::UStringLess > aNameSet;
 387
 388     // search model pool for line starts
 389     createNamesForPool( mpModelPool, XATTR_LINESTART, aNameSet );
 390
 391     // search model pool for line ends
 392     createNamesForPool( mpModelPool, XATTR_LINEEND, aNameSet );
 393
 394     uno::Sequence< OUString > aSeq( aNameSet.size() );
 395     OUString* pNames = aSeq.getArray();
 396
 397     std::set< OUString, comphelper::UStringLess >::iterator aIter( aNameSet.begin() );
 398     const std::set< OUString, comphelper::UStringLess >::iterator aEnd( aNameSet.end() );
 399
 400     while( aIter != aEnd )
 401     {
 402         *pNames++ = *aIter++;
 403     }
 404
 405     return aSeq;
 406 }
 407
 408 sal_Bool SAL_CALL SvxUnoMarkerTable::hasByName( const OUString& aName )
 409     throw( uno::RuntimeException )
 410 {
 411     OGuard aGuard( Application::GetSolarMutex() );
 412
 413     if( aName.getLength() == 0 )
 414         return sal_False;
 415
 416     String aSearchName;
 417
 418     NameOrIndex *pItem;
 419
 420     SvxUnogetInternalNameForItem( XATTR_LINESTART, aName, aSearchName );
 421     USHORT nStartCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINESTART ) : 0;
 422     USHORT nSurrogate;
 423     for( nSurrogate = 0; nSurrogate < nStartCount; nSurrogate++ )
 424     {
 425         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINESTART, nSurrogate);
 426         if( pItem && pItem->GetName() == aSearchName )
 427             return sal_True;
 428     }
 429
 430     SvxUnogetInternalNameForItem( XATTR_LINEEND, aName, aSearchName );
 431     USHORT nEndCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINEEND ) : 0;
 432     for( nSurrogate = 0; nSurrogate < nEndCount; nSurrogate++ )
 433     {
 434         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINEEND, nSurrogate);
 435         if( pItem && pItem->GetName() == aSearchName )
 436             return sal_True;
 437     }
 438
 439     return sal_False;
 440 }
 441
 442 // XElementAccess
 443 uno::Type SAL_CALL SvxUnoMarkerTable::getElementType(  )
 444     throw( uno::RuntimeException )
 445 {
 446     return ::getCppuType((const drawing::PointSequence*)0);
 447 }
 448
 449 sal_Bool SAL_CALL SvxUnoMarkerTable::hasElements(  )
 450     throw( uno::RuntimeException )
 451 {
 452     OGuard aGuard( Application::GetSolarMutex() );
 453
 454     NameOrIndex *pItem;
 455
 456     const USHORT nStartCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINESTART ) : 0;
 457     USHORT nSurrogate;
 458     for( nSurrogate = 0; nSurrogate < nStartCount; nSurrogate++ )
 459     {
 460         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINESTART, nSurrogate);
 461         if( pItem && pItem->GetName().Len() != 0 )
 462             return sal_True;
 463     }
 464
 465     const USHORT nEndCount = mpModelPool ? mpModelPool->GetItemCount( XATTR_LINEEND ) : 0;
 466     for( nSurrogate = 0; nSurrogate < nEndCount; nSurrogate++ )
 467     {
 468         pItem = (NameOrIndex*)mpModelPool->GetItem( XATTR_LINEEND, nSurrogate);
 469         if( pItem && pItem->GetName().Len() != 0 )
 470             return sal_True;
 471     }
 472
 473     return sal_False;
 474 }
 475
 476 /**
 477  * Create a hatchtable
 478  */
 479 uno::Reference< uno::XInterface > SAL_CALL SvxUnoMarkerTable_createInstance( SdrModel* pModel )
 480 {
 481     return *new SvxUnoMarkerTable(pModel);
 482 }
 483
 484
 485