sd/source/ui/unoidl/unolayer.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: unolayer.cxx,v $
  10  * $Revision: 1.15 $
  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_sd.hxx"
  33 #include <com/sun/star/lang/DisposedException.hpp>
  34
  35 #include "unolayer.hxx"
  36 #include <osl/mutex.hxx>
  37 #include <vos/mutex.hxx>
  38
  39 #include <svx/svdpagv.hxx>
  40 #include <svx/unoshape.hxx>
  41 #include <svx/svdobj.hxx>
  42
  43 // folgende fuer InsertSdPage()
  44 #include <svx/svdlayer.hxx>
  45
  46 #ifndef SVX_LIGHT
  47 #ifndef SD_DRAW_DOC_SHELL_HXX
  48 #include "DrawDocShell.hxx"
  49 #endif
  50 #endif
  51 #include <drawdoc.hxx>
  52 #include <unomodel.hxx>
  53 #include "unoprnms.hxx"
  54 #include <com/sun/star/lang/NoSupportException.hpp>
  55
  56 #include "unohelp.hxx"
  57 #include "FrameView.hxx"
  58 #include "DrawViewShell.hxx"
  59 #include "View.hxx"
  60 #include "ViewShell.hxx"
  61 #include "app.hrc"
  62 #include "strings.hrc"
  63 #include "sdresid.hxx"
  64 #include "glob.hrc"
  65
  66 #include "unokywds.hxx"
  67 #include "unowcntr.hxx"
  68 #include <vcl/svapp.hxx>
  69
  70 using namespace ::rtl;
  71 using namespace ::vos;
  72 using namespace ::com::sun::star;
  73
  74 //=============================================================================
  75 // class SdLayer
  76 //=============================================================================
  77
  78 #define WID_LAYER_LOCKED        1
  79 #define WID_LAYER_PRINTABLE     2
  80 #define WID_LAYER_VISIBLE       3
  81 #define WID_LAYER_NAME          4
  82 #define WID_LAYER_TITLE         5
  83 #define WID_LAYER_DESC          6
  84
  85 const SvxItemPropertySet* ImplGetSdLayerPropertySet()
  86 {
  87     static const SfxItemPropertyMapEntry aSdLayerPropertyMap_Impl[] =
  88     {
  89         { MAP_CHAR_LEN(UNO_NAME_LAYER_LOCKED),          WID_LAYER_LOCKED,       &::getBooleanCppuType(),                        0, 0 },
  90         { MAP_CHAR_LEN(UNO_NAME_LAYER_PRINTABLE),       WID_LAYER_PRINTABLE,&::getBooleanCppuType(),                    0, 0 },
  91         { MAP_CHAR_LEN(UNO_NAME_LAYER_VISIBLE),         WID_LAYER_VISIBLE,      &::getBooleanCppuType(),                        0, 0 },
  92         { MAP_CHAR_LEN(UNO_NAME_LAYER_NAME),            WID_LAYER_NAME,         &::getCppuType((const OUString*)0),     0, 0 },
  93         { MAP_CHAR_LEN("Title"),                                        WID_LAYER_TITLE,        &::getCppuType((const OUString*)0),     0, 0 },
  94         { MAP_CHAR_LEN("Description"),                          WID_LAYER_DESC,         &::getCppuType((const OUString*)0),     0, 0 },
  95         { 0,0,0,0,0,0}
  96     };
  97     static SvxItemPropertySet aSDLayerPropertySet_Impl( aSdLayerPropertyMap_Impl );
  98     return &aSDLayerPropertySet_Impl;
  99 }
 100
 101 String SdLayer::convertToInternalName( const OUString& rName )
 102 {
 103     if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_background) ) )
 104     {
 105         return String( SdResId( STR_LAYER_BCKGRND ) );
 106     }
 107     else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_background_objects) ) )
 108     {
 109         return  String( SdResId( STR_LAYER_BCKGRNDOBJ ) );
 110     }
 111     else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_layout) ) )
 112     {
 113         return  String( SdResId( STR_LAYER_LAYOUT ) );
 114     }
 115     else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_controls) ) )
 116     {
 117         return  String( SdResId( STR_LAYER_CONTROLS ) );
 118     }
 119     else if( rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_LayerName_measurelines) ) )
 120     {
 121         return  String( SdResId( STR_LAYER_MEASURELINES ) );
 122     }
 123     else
 124     {
 125         return String( rName );
 126     }
 127 }
 128
 129 OUString SdLayer::convertToExternalName( const String& rName )
 130 {
 131     const String aCompare( rName );
 132     if( rName == String( SdResId( STR_LAYER_BCKGRND ) ) )
 133     {
 134         return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_background) );
 135     }
 136     else if( rName == String( SdResId( STR_LAYER_BCKGRNDOBJ ) ) )
 137     {
 138         return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_background_objects) );
 139     }
 140     else if( rName == String( SdResId( STR_LAYER_LAYOUT ) ) )
 141     {
 142         return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_layout) );
 143     }
 144     else if( rName == String( SdResId( STR_LAYER_CONTROLS ) ) )
 145     {
 146         return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_controls) );
 147     }
 148     else if( rName == String( SdResId( STR_LAYER_MEASURELINES ) ) )
 149     {
 150         return OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_LayerName_measurelines) );
 151     }
 152     else
 153     {
 154         return OUString( rName );
 155     }
 156 }
 157
 158 /** */
 159 SdLayer::SdLayer( SdLayerManager* pLayerManager_, SdrLayer* pSdrLayer_ ) throw()
 160 : pLayerManager(pLayerManager_)
 161 , mxLayerManager(pLayerManager_)
 162 , pLayer(pSdrLayer_)
 163 , pPropSet(ImplGetSdLayerPropertySet())
 164 {
 165 }
 166
 167 /** */
 168 SdLayer::~SdLayer() throw()
 169 {
 170 }
 171
 172 // uno helper
 173 UNO3_GETIMPLEMENTATION_IMPL( SdLayer );
 174
 175 // XServiceInfo
 176 OUString SAL_CALL SdLayer::getImplementationName()
 177     throw(uno::RuntimeException)
 178 {
 179     return OUString( OUString::createFromAscii(sUNO_SdLayer) );
 180 }
 181
 182 sal_Bool SAL_CALL SdLayer::supportsService( const OUString& ServiceName )
 183     throw(uno::RuntimeException)
 184 {
 185     return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
 186 }
 187
 188 uno::Sequence< OUString > SAL_CALL SdLayer::getSupportedServiceNames()
 189     throw(uno::RuntimeException)
 190 {
 191     OUString aServiceName( OUString::createFromAscii(sUNO_Service_DrawingLayer) );
 192     uno::Sequence< OUString > aSeq( &aServiceName, 1 );
 193     return aSeq;
 194 }
 195
 196 // beans::XPropertySet
 197 uno::Reference< beans::XPropertySetInfo > SAL_CALL SdLayer::getPropertySetInfo(  )
 198     throw(uno::RuntimeException)
 199 {
 200     OGuard aGuard( Application::GetSolarMutex() );
 201     return pPropSet->getPropertySetInfo();
 202 }
 203
 204 void SAL_CALL SdLayer::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 205     throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 206 {
 207     OGuard aGuard( Application::GetSolarMutex() );
 208
 209     if(pLayer == NULL || pLayerManager == NULL)
 210         throw lang::DisposedException();
 211
 212     const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(aPropertyName);
 213
 214     switch( pEntry ? pEntry->nWID : -1 )
 215     {
 216     case WID_LAYER_LOCKED:
 217     {
 218         sal_Bool bValue = sal_False;
 219         if(!sd::any2bool( aValue, bValue ))
 220             throw lang::IllegalArgumentException();
 221         set( LOCKED, bValue );
 222         break;
 223     }
 224     case WID_LAYER_PRINTABLE:
 225     {
 226         sal_Bool bValue = sal_False;
 227         if(!sd::any2bool( aValue, bValue ))
 228             throw lang::IllegalArgumentException();
 229         set( PRINTABLE, bValue );
 230         break;
 231     }
 232     case WID_LAYER_VISIBLE:
 233     {
 234         sal_Bool bValue = sal_False;
 235         if(!sd::any2bool( aValue, bValue ))
 236             throw lang::IllegalArgumentException();
 237         set( VISIBLE, bValue );
 238         break;
 239     }
 240     case WID_LAYER_NAME:
 241     {
 242         OUString aName;
 243         if(!(aValue >>= aName))
 244             throw lang::IllegalArgumentException();
 245
 246         pLayer->SetName(SdLayer::convertToInternalName( aName ) );
 247         pLayerManager->UpdateLayerView();
 248         break;
 249     }
 250
 251     case WID_LAYER_TITLE:
 252     {
 253         OUString sTitle;
 254         if(!(aValue >>= sTitle))
 255             throw lang::IllegalArgumentException();
 256
 257         pLayer->SetTitle(sTitle);
 258         break;
 259     }
 260
 261     case WID_LAYER_DESC:
 262     {
 263         OUString sDescription;
 264         if(!(aValue >>= sDescription))
 265             throw lang::IllegalArgumentException();
 266
 267         pLayer->SetDescription(sDescription);
 268         break;
 269     }
 270
 271     default:
 272         throw beans::UnknownPropertyException();
 273     }
 274
 275 #ifndef SVX_LIGHT
 276     if( pLayerManager->GetDocShell() )
 277         pLayerManager->GetDocShell()->SetModified();
 278 #endif
 279 }
 280
 281 uno::Any SAL_CALL SdLayer::getPropertyValue( const OUString& PropertyName )
 282     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 283 {
 284     OGuard aGuard( Application::GetSolarMutex() );
 285
 286     if(pLayer == NULL || pLayerManager == NULL)
 287         throw lang::DisposedException();
 288
 289     const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(PropertyName);
 290
 291     uno::Any aValue;
 292
 293     switch( pEntry ? pEntry->nWID : -1 )
 294     {
 295     case WID_LAYER_LOCKED:
 296         sd::bool2any( get( LOCKED ), aValue );
 297         break;
 298     case WID_LAYER_PRINTABLE:
 299         sd::bool2any( get( PRINTABLE ), aValue );
 300         break;
 301     case WID_LAYER_VISIBLE:
 302         sd::bool2any( get( VISIBLE ), aValue );
 303         break;
 304     case WID_LAYER_NAME:
 305     {
 306         OUString aRet( SdLayer::convertToExternalName( pLayer->GetName() ) );
 307         aValue <<= aRet;
 308         break;
 309     }
 310     case WID_LAYER_TITLE:
 311         aValue <<= OUString( pLayer->GetTitle() );
 312         break;
 313     case WID_LAYER_DESC:
 314         aValue <<= OUString( pLayer->GetDescription() );
 315         break;
 316     default:
 317         throw beans::UnknownPropertyException();
 318     }
 319
 320     return aValue;
 321 }
 322
 323 void SAL_CALL SdLayer::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 324 void SAL_CALL SdLayer::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 325 void SAL_CALL SdLayer::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 326 void SAL_CALL SdLayer::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 327
 328 /** */
 329 sal_Bool SdLayer::get( LayerAttribute what ) throw()
 330 {
 331     if(pLayer&&pLayerManager)
 332     {
 333         // Versuch 1. ist eine beliebige Seite geoeffnet?
 334         ::sd::View *pView = pLayerManager->GetView();
 335         SdrPageView* pSdrPageView = NULL;
 336         if(pView)
 337             pSdrPageView = pView->GetSdrPageView();
 338
 339         if(pSdrPageView)
 340         {
 341             String aLayerName = pLayer->GetName();
 342             switch(what)
 343             {
 344             case VISIBLE:       return pSdrPageView->IsLayerVisible(aLayerName);
 345             case PRINTABLE:     return pSdrPageView->IsLayerPrintable(aLayerName);
 346             case LOCKED:        return pSdrPageView->IsLayerLocked(aLayerName);
 347             }
 348         }
 349
 350 #ifndef SVX_LIGHT
 351         // Versuch 2. Info von der FrameView besorgen
 352         if(pLayerManager->GetDocShell())
 353         {
 354             ::sd::FrameView *pFrameView = pLayerManager->GetDocShell()->GetFrameView();
 355             if(pFrameView)
 356                 switch(what)
 357                 {
 358                 case VISIBLE:   return pFrameView->GetVisibleLayers().IsSet(pLayer->GetID());
 359                 case PRINTABLE: return pFrameView->GetPrintableLayers().IsSet(pLayer->GetID());
 360                 case LOCKED:    return pFrameView->GetLockedLayers().IsSet(pLayer->GetID());
 361                 }
 362         }
 363 #endif
 364     }
 365     return sal_False; //TODO: uno::Exception?
 366 }
 367
 368 void SdLayer::set( LayerAttribute what, sal_Bool flag ) throw()
 369 {
 370     if(pLayer&&pLayerManager)
 371     {
 372         // Versuch 1. ist eine beliebige Seite geoeffnet?
 373         ::sd::View *pView = pLayerManager->GetView();
 374         SdrPageView* pSdrPageView = NULL;
 375         if(pView)
 376             pSdrPageView = pView->GetSdrPageView();
 377
 378         if(pSdrPageView)
 379         {
 380             String aLayerName(pLayer->GetName());
 381             switch(what)
 382             {
 383             case VISIBLE:       pSdrPageView->SetLayerVisible(aLayerName,flag);
 384                             break;
 385             case PRINTABLE:     pSdrPageView->SetLayerPrintable(aLayerName,flag);
 386                             break;
 387             case LOCKED:        pSdrPageView->SetLayerLocked(aLayerName,flag);
 388                             break;
 389             }
 390         }
 391
 392 #ifndef SVX_LIGHT
 393         // Versuch 2. Info von der FrameView besorgen
 394         if(pLayerManager->GetDocShell())
 395         {
 396             ::sd::FrameView *pFrameView = pLayerManager->GetDocShell()->GetFrameView();
 397
 398             if(pFrameView)
 399             {
 400                 SetOfByte aNewLayers;
 401                 switch(what)
 402                 {
 403                 case VISIBLE:   aNewLayers = pFrameView->GetVisibleLayers();
 404                                 break;
 405                 case PRINTABLE: aNewLayers = pFrameView->GetPrintableLayers();
 406                                 break;
 407                 case LOCKED:    aNewLayers = pFrameView->GetLockedLayers();
 408                                 break;
 409                 }
 410
 411                 aNewLayers.Set(pLayer->GetID(),flag);
 412
 413                 switch(what)
 414                 {
 415                 case VISIBLE:   pFrameView->SetVisibleLayers(aNewLayers);
 416                                 break;
 417                 case PRINTABLE: pFrameView->SetPrintableLayers(aNewLayers);
 418                                 break;
 419                 case LOCKED:    pFrameView->SetLockedLayers(aNewLayers);
 420                                 break;
 421                 }
 422                 return;
 423             }
 424         }
 425 #endif
 426     }
 427     //TODO: uno::Exception?
 428 }
 429
 430
 431
 432
 433 //=====  ::com::sun::star::container::XChild  =================================
 434
 435 uno::Reference<uno::XInterface> SAL_CALL SdLayer::getParent (void)
 436     throw (::com::sun::star::uno::RuntimeException)
 437 {
 438     OGuard aGuard( Application::GetSolarMutex() );
 439
 440     if( pLayerManager == NULL )
 441         throw lang::DisposedException();
 442
 443     return uno::Reference<uno::XInterface> (mxLayerManager, uno::UNO_QUERY);
 444 }
 445
 446
 447 void SAL_CALL SdLayer::setParent (const uno::Reference<uno::XInterface >& )
 448     throw (::com::sun::star::lang::NoSupportException,
 449         ::com::sun::star::uno::RuntimeException)
 450 {
 451     throw lang::NoSupportException ();
 452 }
 453
 454 // XComponent
 455 void SAL_CALL SdLayer::dispose(  ) throw (uno::RuntimeException)
 456 {
 457     pLayerManager = 0;
 458     mxLayerManager = 0;
 459     pLayer = 0;
 460 }
 461
 462 void SAL_CALL SdLayer::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
 463 {
 464     DBG_ERROR("not implemented!");
 465 }
 466
 467 void SAL_CALL SdLayer::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
 468 {
 469     DBG_ERROR("not implemented!");
 470 }
 471
 472
 473 //=============================================================================
 474 // class SdLayerManager
 475 //=============================================================================
 476
 477 /** */
 478 SdLayerManager::SdLayerManager( SdXImpressDocument& rMyModel ) throw()
 479 :mpModel( &rMyModel)
 480 {
 481     mpLayers = new SvUnoWeakContainer;
 482 }
 483
 484 /** */
 485 SdLayerManager::~SdLayerManager() throw()
 486 {
 487     dispose();
 488 }
 489
 490 // uno helper
 491 UNO3_GETIMPLEMENTATION_IMPL( SdLayerManager );
 492
 493 // XComponent
 494 void SAL_CALL SdLayerManager::dispose(  ) throw (uno::RuntimeException)
 495 {
 496     mpModel = 0;
 497     if( mpLayers )
 498     {
 499         mpLayers->dispose();
 500
 501         delete mpLayers;
 502         mpLayers = 0;
 503     }
 504 }
 505
 506 void SAL_CALL SdLayerManager::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
 507 {
 508     DBG_ERROR("not implemented!");
 509 }
 510
 511 void SAL_CALL SdLayerManager::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
 512 {
 513     DBG_ERROR("not implemented!");
 514 }
 515
 516 // XServiceInfo
 517 OUString SAL_CALL SdLayerManager::getImplementationName()
 518     throw(uno::RuntimeException)
 519 {
 520     return OUString( OUString::createFromAscii(sUNO_SdLayerManager) );
 521 }
 522
 523 sal_Bool SAL_CALL SdLayerManager::supportsService( const OUString& ServiceName )
 524     throw(uno::RuntimeException)
 525 {
 526     return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
 527 }
 528
 529 uno::Sequence< OUString > SAL_CALL SdLayerManager::getSupportedServiceNames()
 530     throw(uno::RuntimeException)
 531 {
 532     OUString aServiceName( OUString::createFromAscii(sUNO_Service_DrawingLayerManager) );
 533     uno::Sequence< OUString > aSeq( &aServiceName, 1 );
 534     return aSeq;
 535 }
 536
 537 // XLayerManager
 538 uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::insertNewByIndex( sal_Int32 nIndex )
 539     throw(uno::RuntimeException)
 540 {
 541     OGuard aGuard( Application::GetSolarMutex() );
 542
 543     if( mpModel == 0 )
 544         throw lang::DisposedException();
 545
 546     uno::Reference< drawing::XLayer > xLayer;
 547
 548     if( mpModel->mpDoc )
 549     {
 550         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 551         sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
 552         sal_uInt16 nLayer = nLayerCnt - 2 + 1;
 553         String aLayerName;
 554
 555         // Ueberpruefung auf schon vorhandene Namen
 556         while( aLayerName.Len()==0 || rLayerAdmin.GetLayer( aLayerName, sal_False) )
 557         {
 558             aLayerName = String(SdResId(STR_LAYER));
 559             aLayerName += String::CreateFromInt32( (sal_Int32)nLayer );
 560             nLayer++;
 561         }
 562
 563         SdrLayerAdmin& rLA=mpModel->mpDoc->GetLayerAdmin();
 564         const sal_Int32 nMax=rLA.GetLayerCount();
 565         if (nIndex>nMax) nIndex=nMax;
 566         xLayer = GetLayer (rLA.NewLayer(aLayerName,(USHORT)nIndex));
 567         mpModel->SetModified();
 568     }
 569     return xLayer;
 570 }
 571
 572 void SAL_CALL SdLayerManager::remove( const uno::Reference< drawing::XLayer >& xLayer )
 573     throw(container::NoSuchElementException, uno::RuntimeException)
 574 {
 575     OGuard aGuard( Application::GetSolarMutex() );
 576
 577     if( mpModel == 0 )
 578         throw lang::DisposedException();
 579
 580     SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);
 581
 582     if(pSdLayer && GetView())
 583     {
 584         const SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer();
 585         GetView()->DeleteLayer( pSdrLayer->GetName() );
 586
 587         UpdateLayerView();
 588     }
 589
 590     mpModel->SetModified();
 591 }
 592
 593 void SAL_CALL SdLayerManager::attachShapeToLayer( const uno::Reference< drawing::XShape >& xShape, const uno::Reference< drawing::XLayer >& xLayer )
 594     throw(uno::RuntimeException)
 595 {
 596     OGuard aGuard( Application::GetSolarMutex() );
 597
 598     if( mpModel == 0 )
 599         throw lang::DisposedException();
 600
 601     SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);
 602     SdrLayer* pSdrLayer = pSdLayer?pSdLayer->GetSdrLayer():NULL;
 603     if(pSdrLayer==NULL)
 604         return;
 605
 606     SvxShape* pShape = SvxShape::getImplementation( xShape );
 607     SdrObject* pSdrObject = pShape?pShape->GetSdrObject():NULL;
 608
 609     if(pSdrObject && pSdrLayer )
 610         pSdrObject->SetLayer(pSdrLayer->GetID());
 611
 612     mpModel->SetModified();
 613 }
 614
 615 uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::getLayerForShape( const uno::Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
 616 {
 617     OGuard aGuard( Application::GetSolarMutex() );
 618
 619     if( mpModel == 0 )
 620         throw lang::DisposedException();
 621
 622     uno::Reference< drawing::XLayer >  xLayer;
 623
 624     if(mpModel->mpDoc)
 625     {
 626         SvxShape* pShape = SvxShape::getImplementation( xShape );
 627         SdrObject* pObj = pShape?pShape->GetSdrObject():NULL;
 628         if(pObj)
 629         {
 630             SdrLayerID aId = pObj->GetLayer();
 631             SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 632             xLayer = GetLayer (rLayerAdmin.GetLayerPerID(aId));
 633         }
 634     }
 635     return xLayer;
 636 }
 637
 638 // XIndexAccess
 639 sal_Int32 SAL_CALL SdLayerManager::getCount()
 640     throw(uno::RuntimeException)
 641 {
 642     OGuard aGuard( Application::GetSolarMutex() );
 643
 644     if( mpModel == 0 )
 645         throw lang::DisposedException();
 646
 647     if( mpModel->mpDoc )
 648     {
 649         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 650         return rLayerAdmin.GetLayerCount();
 651     }
 652
 653     return 0;
 654 }
 655
 656 uno::Any SAL_CALL SdLayerManager::getByIndex( sal_Int32 nLayer )
 657     throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
 658 {
 659     OGuard aGuard( Application::GetSolarMutex() );
 660
 661     if( mpModel == 0 )
 662         throw lang::DisposedException();
 663
 664     if( nLayer >= getCount() || nLayer < 0 )
 665         throw lang::IndexOutOfBoundsException();
 666
 667     uno::Any aAny;
 668
 669     if( mpModel->mpDoc )
 670     {
 671         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 672         uno::Reference<drawing::XLayer> xLayer (GetLayer (rLayerAdmin.GetLayer((sal_uInt16)nLayer)));
 673         aAny <<= xLayer;
 674     }
 675     return aAny;
 676 }
 677
 678
 679 // XNameAccess
 680 uno::Any SAL_CALL SdLayerManager::getByName( const OUString& aName )
 681     throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 682 {
 683     OGuard aGuard( Application::GetSolarMutex() );
 684
 685     if( (mpModel == 0) || (mpModel->mpDoc == 0 ) )
 686         throw lang::DisposedException();
 687
 688     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 689     SdrLayer* pLayer = rLayerAdmin.GetLayer( SdLayer::convertToInternalName( aName ), FALSE );
 690     if( pLayer == NULL )
 691         throw container::NoSuchElementException();
 692
 693     return uno::Any( GetLayer (pLayer) );
 694 }
 695
 696 uno::Sequence< OUString > SAL_CALL SdLayerManager::getElementNames()
 697     throw(uno::RuntimeException)
 698 {
 699     OGuard aGuard( Application::GetSolarMutex() );
 700
 701     if( mpModel == 0 )
 702         throw lang::DisposedException();
 703
 704     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 705     const sal_uInt16 nLayerCount = rLayerAdmin.GetLayerCount();
 706
 707     uno::Sequence< OUString > aSeq( nLayerCount );
 708
 709     OUString* pStrings = aSeq.getArray();
 710     SdrLayer* pLayer;
 711
 712     for( sal_uInt16 nLayer = 0; nLayer < nLayerCount; nLayer++ )
 713     {
 714         pLayer = rLayerAdmin.GetLayer( nLayer );
 715         if( pLayer )
 716             *pStrings++ = SdLayer::convertToExternalName( pLayer->GetName() );
 717     }
 718
 719     return aSeq;
 720 }
 721
 722 sal_Bool SAL_CALL SdLayerManager::hasByName( const OUString& aName ) throw(uno::RuntimeException)
 723 {
 724     OGuard aGuard( Application::GetSolarMutex() );
 725
 726     if( mpModel == 0 )
 727         throw lang::DisposedException();
 728
 729     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 730
 731     return NULL != rLayerAdmin.GetLayer( SdLayer::convertToInternalName( aName ), FALSE );
 732 }
 733
 734 // XElementAccess
 735 uno::Type SAL_CALL SdLayerManager::getElementType()
 736     throw(uno::RuntimeException)
 737 {
 738     return ITYPE( drawing::XLayer );
 739 }
 740
 741 sal_Bool SAL_CALL SdLayerManager::hasElements() throw(uno::RuntimeException)
 742 {
 743     return getCount() > 0;
 744 }
 745
 746 /** Falls an den Layern was geaendert wurde sorgt diese Methode dafuer, das
 747     die Aenderungen auch in der sdbcx::View sichtbar gemacht werden */
 748 void SdLayerManager::UpdateLayerView( sal_Bool modify ) const throw()
 749 {
 750     if(mpModel->mpDocShell)
 751     {
 752         ::sd::DrawViewShell* pDrViewSh =
 753             PTR_CAST(::sd::DrawViewShell, mpModel->mpDocShell->GetViewShell());
 754
 755         if(pDrViewSh)
 756         {
 757             sal_Bool bLayerMode = pDrViewSh->IsLayerModeActive();
 758             pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), !bLayerMode);
 759             pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), bLayerMode);
 760         }
 761
 762         if(modify)
 763             mpModel->mpDoc->SetChanged(sal_True);
 764     }
 765 }
 766
 767 /** */
 768 ::sd::View* SdLayerManager::GetView() const throw()
 769 {
 770     if( mpModel->mpDocShell )
 771     {
 772         ::sd::ViewShell* pViewSh = mpModel->mpDocShell->GetViewShell();
 773         if(pViewSh)
 774             return pViewSh->GetView();
 775     }
 776     return NULL;
 777 }
 778
 779
 780
 781 namespace
 782 {
 783 /** Compare two pointers to <type>SdrLayer</type> objects.
 784     @param xRef
 785         The implementing SdLayer class provides the first pointer by the
 786         <member>SdLayer::GetSdrLayer</member> method.
 787     @param pSearchData
 788         This void pointer is the second pointer to an <type>SdrLayer</type>
 789         object.
 790     @return
 791         Return </True> if both pointers point to the same object.
 792 */
 793 sal_Bool compare_layers (uno::WeakReference<uno::XInterface> xRef, void* pSearchData)
 794 {
 795     uno::Reference<uno::XInterface> xLayer (xRef);
 796     if (xLayer.is())
 797     {
 798         SdLayer* pSdLayer = SdLayer::getImplementation (xRef);
 799         if (pSdLayer != NULL)
 800         {
 801             SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer ();
 802             if (pSdrLayer == static_cast<SdrLayer*>(pSearchData))
 803                 return sal_True;
 804         }
 805     }
 806     return sal_False;
 807 }
 808 }
 809
 810 /** Use the <member>mpLayers</member> container of weak references to either
 811     retrieve and return a previously created <type>XLayer</type> object for
 812     the given <type>SdrLayer</type> object or create and remember a new one.
 813 */
 814 uno::Reference<drawing::XLayer> SdLayerManager::GetLayer (SdrLayer* pLayer)
 815 {
 816     uno::WeakReference<uno::XInterface> xRef;
 817     uno::Reference<drawing::XLayer>  xLayer;
 818
 819     // Search existing xLayer for the given pLayer.
 820     if (mpLayers->findRef (xRef, (void*)pLayer, compare_layers))
 821         xLayer = uno::Reference<drawing::XLayer> (xRef, uno::UNO_QUERY);
 822
 823     // Create the xLayer if necessary.
 824     if ( ! xLayer.is())
 825     {
 826         xLayer = new SdLayer (this, pLayer);
 827
 828         // Remember the new xLayer for future calls.
 829         xRef = uno::Reference<uno::XInterface> (xLayer, uno::UNO_QUERY);
 830         mpLayers->insert (xRef);
 831     }
 832
 833     return xLayer;
 834 }