sd/source/ui/unoidl/unolayer.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/lang/DisposedException.hpp>
  21 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  22
  23 #include "unolayer.hxx"
  24
  25 #include <comphelper/extract.hxx>
  26 #include <svx/svdpagv.hxx>
  27 #include <svx/unoshape.hxx>
  28 #include <svx/svdobj.hxx>
  29 #include <cppuhelper/supportsservice.hxx>
  30
  31 // following ones for InsertSdPage()
  32 #include <svx/svdlayer.hxx>
  33
  34 #include <DrawDocShell.hxx>
  35 #include <drawdoc.hxx>
  36 #include <unomodel.hxx>
  37 #include <unoprnms.hxx>
  38 #include <com/sun/star/lang/NoSupportException.hpp>
  39 #include <svx/svdpool.hxx>
  40 #include <FrameView.hxx>
  41 #include <DrawViewShell.hxx>
  42 #include <View.hxx>
  43 #include <ViewShell.hxx>
  44 #include <app.hrc>
  45 #include <strings.hrc>
  46 #include <sdresid.hxx>
  47
  48 #include <unokywds.hxx>
  49 #include "unowcntr.hxx"
  50 #include <vcl/svapp.hxx>
  51
  52 using namespace ::com::sun::star;
  53
  54 // class SdLayer
  55 #define WID_LAYER_LOCKED    1
  56 #define WID_LAYER_PRINTABLE 2
  57 #define WID_LAYER_VISIBLE   3
  58 #define WID_LAYER_NAME      4
  59 #define WID_LAYER_TITLE     5
  60 #define WID_LAYER_DESC      6
  61
  62 static const SvxItemPropertySet* ImplGetSdLayerPropertySet()
  63 {
  64     static const SfxItemPropertyMapEntry aSdLayerPropertyMap_Impl[] =
  65     {
  66         { OUString(UNO_NAME_LAYER_LOCKED),      WID_LAYER_LOCKED,   cppu::UnoType<bool>::get(),            0, 0 },
  67         { OUString(UNO_NAME_LAYER_PRINTABLE),   WID_LAYER_PRINTABLE,cppu::UnoType<bool>::get(),            0, 0 },
  68         { OUString(UNO_NAME_LAYER_VISIBLE),     WID_LAYER_VISIBLE,  cppu::UnoType<bool>::get(),            0, 0 },
  69         { OUString(UNO_NAME_LAYER_NAME),        WID_LAYER_NAME,     ::cppu::UnoType<OUString>::get(), 0, 0 },
  70         { OUString("Title"),                    WID_LAYER_TITLE,    ::cppu::UnoType<OUString>::get(), 0, 0 },
  71         { OUString("Description"),              WID_LAYER_DESC,     ::cppu::UnoType<OUString>::get(), 0, 0 },
  72         { OUString(), 0, css::uno::Type(), 0, 0 }
  73     };
  74     static SvxItemPropertySet aSDLayerPropertySet_Impl( aSdLayerPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
  75     return &aSDLayerPropertySet_Impl;
  76 }
  77
  78 SdLayer::SdLayer(SdLayerManager* pLayerManager_, SdrLayer* pSdrLayer_)
  79 : mxLayerManager(pLayerManager_)
  80 , pLayer(pSdrLayer_)
  81 , pPropSet(ImplGetSdLayerPropertySet())
  82 {
  83     // no defaults possible yet, a "set" would overwrite existing information
  84     // in view, which is currently needed for saving, because pLayer is not updated
  85     // from view.
  86 }
  87
  88 SdLayer::~SdLayer() throw()
  89 {
  90 }
  91
  92 // uno helper
  93 UNO3_GETIMPLEMENTATION_IMPL( SdLayer );
  94
  95 // XServiceInfo
  96 OUString SAL_CALL SdLayer::getImplementationName()
  97 {
  98     return OUString("SdUnoLayer");
  99 }
 100
 101 sal_Bool SAL_CALL SdLayer::supportsService( const OUString& ServiceName )
 102 {
 103     return cppu::supportsService( this, ServiceName );
 104 }
 105
 106 uno::Sequence< OUString > SAL_CALL SdLayer::getSupportedServiceNames()
 107 {
 108     OUString aServiceName("com.sun.star.drawing.Layer");
 109     uno::Sequence< OUString > aSeq( &aServiceName, 1 );
 110     return aSeq;
 111 }
 112
 113 // beans::XPropertySet
 114 uno::Reference< beans::XPropertySetInfo > SAL_CALL SdLayer::getPropertySetInfo(  )
 115 {
 116     SolarMutexGuard aGuard;
 117     return pPropSet->getPropertySetInfo();
 118 }
 119
 120 void SAL_CALL SdLayer::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 121 {
 122     SolarMutexGuard aGuard;
 123
 124     if(pLayer == nullptr || mxLayerManager == nullptr)
 125         throw lang::DisposedException();
 126
 127     const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(aPropertyName);
 128
 129     switch( pEntry ? pEntry->nWID : -1 )
 130     {
 131     case WID_LAYER_LOCKED:
 132     {
 133         pLayer->SetLockedODF( cppu::any2bool(aValue) );
 134         set(LOCKED, cppu::any2bool(aValue)); // changes the View, if any exists
 135         break;
 136     }
 137     case WID_LAYER_PRINTABLE:
 138     {
 139         pLayer->SetPrintableODF( cppu::any2bool(aValue) );
 140         set(PRINTABLE, cppu::any2bool(aValue)); // changes the View, if any exists
 141         break;
 142     }
 143     case WID_LAYER_VISIBLE:
 144     {
 145         pLayer->SetVisibleODF( cppu::any2bool(aValue) );
 146         set(VISIBLE, cppu::any2bool(aValue)); // changes the View, if any exists
 147         break;
 148     }
 149     case WID_LAYER_NAME:
 150     {
 151         OUString aName;
 152         if(!(aValue >>= aName))
 153             throw lang::IllegalArgumentException();
 154
 155         pLayer->SetName(aName);
 156         mxLayerManager->UpdateLayerView();
 157         break;
 158     }
 159
 160     case WID_LAYER_TITLE:
 161     {
 162         OUString sTitle;
 163         if(!(aValue >>= sTitle))
 164             throw lang::IllegalArgumentException();
 165
 166         pLayer->SetTitle(sTitle);
 167         break;
 168     }
 169
 170     case WID_LAYER_DESC:
 171     {
 172         OUString sDescription;
 173         if(!(aValue >>= sDescription))
 174             throw lang::IllegalArgumentException();
 175
 176         pLayer->SetDescription(sDescription);
 177         break;
 178     }
 179
 180     default:
 181         throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
 182     }
 183
 184     if( mxLayerManager->GetDocShell() )
 185         mxLayerManager->GetDocShell()->SetModified();
 186 }
 187
 188 uno::Any SAL_CALL SdLayer::getPropertyValue( const OUString& PropertyName )
 189 {
 190     SolarMutexGuard aGuard;
 191
 192     if(pLayer == nullptr || mxLayerManager == nullptr)
 193         throw lang::DisposedException();
 194
 195     const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMapEntry(PropertyName);
 196
 197     uno::Any aValue;
 198
 199     switch( pEntry ? pEntry->nWID : -1 )
 200     {
 201     case WID_LAYER_LOCKED:
 202         aValue <<= get( LOCKED );
 203         break;
 204     case WID_LAYER_PRINTABLE:
 205         aValue <<= get( PRINTABLE );
 206         break;
 207     case WID_LAYER_VISIBLE:
 208         aValue <<= get( VISIBLE );
 209         break;
 210     case WID_LAYER_NAME:
 211     {
 212         OUString aRet(pLayer->GetName());
 213         aValue <<= aRet;
 214         break;
 215     }
 216     case WID_LAYER_TITLE:
 217         aValue <<= pLayer->GetTitle();
 218         break;
 219     case WID_LAYER_DESC:
 220         aValue <<= pLayer->GetDescription();
 221         break;
 222     default:
 223         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
 224     }
 225
 226     return aValue;
 227 }
 228
 229 void SAL_CALL SdLayer::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
 230 void SAL_CALL SdLayer::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
 231 void SAL_CALL SdLayer::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
 232 void SAL_CALL SdLayer::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
 233
 234 bool SdLayer::get( LayerAttribute what ) throw()
 235 {
 236     if(pLayer && mxLayerManager.is())
 237     {
 238         // Try 1. is an arbitrary page open?
 239         ::sd::View *pView = mxLayerManager->GetView();
 240         SdrPageView* pSdrPageView = nullptr;
 241         if(pView)
 242             pSdrPageView = pView->GetSdrPageView();
 243
 244         if(pSdrPageView)
 245         {
 246             OUString aLayerName = pLayer->GetName();
 247             switch(what)
 248             {
 249             case VISIBLE:   return pSdrPageView->IsLayerVisible(aLayerName);
 250             case PRINTABLE: return pSdrPageView->IsLayerPrintable(aLayerName);
 251             case LOCKED:    return pSdrPageView->IsLayerLocked(aLayerName);
 252             }
 253         }
 254
 255         // Try 2. get info from FrameView
 256         if(mxLayerManager->GetDocShell())
 257         {
 258             ::sd::FrameView *pFrameView = mxLayerManager->GetDocShell()->GetFrameView();
 259             if(pFrameView)
 260                 switch(what)
 261                 {
 262                 case VISIBLE:   return pFrameView->GetVisibleLayers().IsSet(pLayer->GetID());
 263                 case PRINTABLE: return pFrameView->GetPrintableLayers().IsSet(pLayer->GetID());
 264                 case LOCKED:    return pFrameView->GetLockedLayers().IsSet(pLayer->GetID());
 265                 }
 266         }
 267     }
 268     return false; //TODO: uno::Exception?
 269 }
 270
 271 void SdLayer::set( LayerAttribute what, bool flag ) throw()
 272 {
 273     if(!(pLayer && mxLayerManager.is()))
 274         return;
 275
 276     // Try 1. is an arbitrary page open?
 277     ::sd::View *pView = mxLayerManager->GetView();
 278     SdrPageView* pSdrPageView = nullptr;
 279     if(pView)
 280         pSdrPageView = pView->GetSdrPageView();
 281
 282     if(pSdrPageView)
 283     {
 284         OUString aLayerName(pLayer->GetName());
 285         switch(what)
 286         {
 287         case VISIBLE:   pSdrPageView->SetLayerVisible(aLayerName,flag);
 288                         break;
 289         case PRINTABLE: pSdrPageView->SetLayerPrintable(aLayerName,flag);
 290                         break;
 291         case LOCKED:    pSdrPageView->SetLayerLocked(aLayerName,flag);
 292                         break;
 293         }
 294     }
 295
 296     // Try 2. get info from FrameView
 297     if(!mxLayerManager->GetDocShell())
 298         return;
 299
 300     ::sd::FrameView *pFrameView = mxLayerManager->GetDocShell()->GetFrameView();
 301
 302     if(!pFrameView)
 303         return;
 304
 305     SdrLayerIDSet aNewLayers;
 306     switch(what)
 307     {
 308     case VISIBLE:   aNewLayers = pFrameView->GetVisibleLayers();
 309                     break;
 310     case PRINTABLE: aNewLayers = pFrameView->GetPrintableLayers();
 311                     break;
 312     case LOCKED:    aNewLayers = pFrameView->GetLockedLayers();
 313                     break;
 314     }
 315
 316     aNewLayers.Set(pLayer->GetID(),flag);
 317
 318     switch(what)
 319     {
 320     case VISIBLE:   pFrameView->SetVisibleLayers(aNewLayers);
 321                     break;
 322     case PRINTABLE: pFrameView->SetPrintableLayers(aNewLayers);
 323                     break;
 324     case LOCKED:    pFrameView->SetLockedLayers(aNewLayers);
 325                     break;
 326     }
 327     return;
 328     //TODO: uno::Exception?
 329 }
 330
 331 // css::container::XChild
 332 uno::Reference<uno::XInterface> SAL_CALL SdLayer::getParent()
 333 {
 334     SolarMutexGuard aGuard;
 335
 336     if( !mxLayerManager.is() )
 337         throw lang::DisposedException();
 338
 339     return uno::Reference<uno::XInterface> (static_cast<cppu::OWeakObject*>(mxLayerManager.get()), uno::UNO_QUERY);
 340 }
 341
 342 void SAL_CALL SdLayer::setParent (const uno::Reference<uno::XInterface >& )
 343 {
 344     throw lang::NoSupportException ();
 345 }
 346
 347 // XComponent
 348 void SAL_CALL SdLayer::dispose(  )
 349 {
 350     mxLayerManager.clear();
 351     pLayer = nullptr;
 352 }
 353
 354 void SAL_CALL SdLayer::addEventListener( const uno::Reference< lang::XEventListener >& )
 355 {
 356     OSL_FAIL("not implemented!");
 357 }
 358
 359 void SAL_CALL SdLayer::removeEventListener( const uno::Reference< lang::XEventListener >& )
 360 {
 361     OSL_FAIL("not implemented!");
 362 }
 363
 364 // class SdLayerManager
 365 SdLayerManager::SdLayerManager( SdXImpressDocument& rMyModel ) throw()
 366 :mpModel( &rMyModel)
 367 {
 368     mpLayers.reset(new SvUnoWeakContainer);
 369 }
 370
 371 SdLayerManager::~SdLayerManager() throw()
 372 {
 373     dispose();
 374 }
 375
 376 // uno helper
 377 UNO3_GETIMPLEMENTATION_IMPL( SdLayerManager );
 378
 379 // XComponent
 380 void SAL_CALL SdLayerManager::dispose(  )
 381 {
 382     mpModel = nullptr;
 383     if( mpLayers )
 384     {
 385         mpLayers->dispose();
 386         mpLayers.reset();
 387     }
 388 }
 389
 390 void SAL_CALL SdLayerManager::addEventListener( const uno::Reference< lang::XEventListener >& )
 391 {
 392     OSL_FAIL("not implemented!");
 393 }
 394
 395 void SAL_CALL SdLayerManager::removeEventListener( const uno::Reference< lang::XEventListener >& )
 396 {
 397     OSL_FAIL("not implemented!");
 398 }
 399
 400 // XServiceInfo
 401 OUString SAL_CALL SdLayerManager::getImplementationName()
 402 {
 403     return OUString("SdUnoLayerManager");
 404 }
 405
 406 sal_Bool SAL_CALL SdLayerManager::supportsService( const OUString& ServiceName )
 407 {
 408     return cppu::supportsService( this, ServiceName );
 409 }
 410
 411 uno::Sequence< OUString > SAL_CALL SdLayerManager::getSupportedServiceNames()
 412 {
 413     uno::Sequence< OUString > aSeq { "com.sun.star.drawing.LayerManager" };
 414     return aSeq;
 415 }
 416
 417 // XLayerManager
 418 uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::insertNewByIndex( sal_Int32 nIndex )
 419 {
 420     SolarMutexGuard aGuard;
 421
 422     if( mpModel == nullptr )
 423         throw lang::DisposedException();
 424
 425     uno::Reference< drawing::XLayer > xLayer;
 426
 427     if( mpModel->mpDoc )
 428     {
 429         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 430         sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
 431         sal_Int32 nLayer = nLayerCnt - 2 + 1;
 432         OUString aLayerName;
 433
 434         // Test for existing names
 435         while( aLayerName.isEmpty() || rLayerAdmin.GetLayer( aLayerName ) )
 436         {
 437             aLayerName = SdResId(STR_LAYER) + OUString::number(nLayer);
 438             ++nLayer;
 439         }
 440
 441         SdrLayerAdmin& rLA=mpModel->mpDoc->GetLayerAdmin();
 442         const sal_Int32 nMax=rLA.GetLayerCount();
 443         if (nIndex>nMax) nIndex=nMax;
 444         xLayer = GetLayer (rLA.NewLayer(aLayerName,static_cast<sal_uInt16>(nIndex)));
 445         mpModel->SetModified();
 446     }
 447     return xLayer;
 448 }
 449
 450 void SAL_CALL SdLayerManager::remove( const uno::Reference< drawing::XLayer >& xLayer )
 451 {
 452     SolarMutexGuard aGuard;
 453
 454     if( mpModel == nullptr )
 455         throw lang::DisposedException();
 456
 457     SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);
 458
 459     if(pSdLayer && GetView())
 460     {
 461         const SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer();
 462         GetView()->DeleteLayer( pSdrLayer->GetName() );
 463
 464         UpdateLayerView();
 465     }
 466
 467     mpModel->SetModified();
 468 }
 469
 470 void SAL_CALL SdLayerManager::attachShapeToLayer( const uno::Reference< drawing::XShape >& xShape, const uno::Reference< drawing::XLayer >& xLayer )
 471 {
 472     SolarMutexGuard aGuard;
 473
 474     if( mpModel == nullptr )
 475         throw lang::DisposedException();
 476
 477     SdLayer* pSdLayer = SdLayer::getImplementation(xLayer);
 478     SdrLayer* pSdrLayer = pSdLayer?pSdLayer->GetSdrLayer():nullptr;
 479     if(pSdrLayer==nullptr)
 480         return;
 481
 482     SvxShape* pShape = SvxShape::getImplementation( xShape );
 483     SdrObject* pSdrObject = pShape?pShape->GetSdrObject():nullptr;
 484
 485     if(pSdrObject)
 486         pSdrObject->SetLayer(pSdrLayer->GetID());
 487
 488     mpModel->SetModified();
 489 }
 490
 491 uno::Reference< drawing::XLayer > SAL_CALL SdLayerManager::getLayerForShape( const uno::Reference< drawing::XShape >& xShape )
 492 {
 493     SolarMutexGuard aGuard;
 494
 495     if( mpModel == nullptr )
 496         throw lang::DisposedException();
 497
 498     uno::Reference< drawing::XLayer >  xLayer;
 499
 500     if(mpModel->mpDoc)
 501     {
 502         SvxShape* pShape = SvxShape::getImplementation( xShape );
 503         SdrObject* pObj = pShape?pShape->GetSdrObject():nullptr;
 504         if(pObj)
 505         {
 506             SdrLayerID aId = pObj->GetLayer();
 507             SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 508             xLayer = GetLayer (rLayerAdmin.GetLayerPerID(aId));
 509         }
 510     }
 511     return xLayer;
 512 }
 513
 514 // XIndexAccess
 515 sal_Int32 SAL_CALL SdLayerManager::getCount()
 516 {
 517     SolarMutexGuard aGuard;
 518
 519     if( mpModel == nullptr )
 520         throw lang::DisposedException();
 521
 522     if( mpModel->mpDoc )
 523     {
 524         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 525         return rLayerAdmin.GetLayerCount();
 526     }
 527
 528     return 0;
 529 }
 530
 531 uno::Any SAL_CALL SdLayerManager::getByIndex( sal_Int32 nLayer )
 532 {
 533     SolarMutexGuard aGuard;
 534
 535     if( mpModel == nullptr )
 536         throw lang::DisposedException();
 537
 538     if( nLayer >= getCount() || nLayer < 0 )
 539         throw lang::IndexOutOfBoundsException();
 540
 541     uno::Any aAny;
 542
 543     if( mpModel->mpDoc )
 544     {
 545         SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 546         uno::Reference<drawing::XLayer> xLayer (GetLayer (rLayerAdmin.GetLayer(static_cast<sal_uInt16>(nLayer))));
 547         aAny <<= xLayer;
 548     }
 549     return aAny;
 550 }
 551
 552 // XNameAccess
 553 uno::Any SAL_CALL SdLayerManager::getByName( const OUString& aName )
 554 {
 555     SolarMutexGuard aGuard;
 556
 557     if( (mpModel == nullptr) || (mpModel->mpDoc == nullptr ) )
 558         throw lang::DisposedException();
 559
 560     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 561     SdrLayer* pLayer = rLayerAdmin.GetLayer(aName);
 562     if( pLayer == nullptr )
 563         throw container::NoSuchElementException();
 564
 565     return uno::Any( GetLayer (pLayer) );
 566 }
 567
 568 uno::Sequence< OUString > SAL_CALL SdLayerManager::getElementNames()
 569 {
 570     SolarMutexGuard aGuard;
 571
 572     if( mpModel == nullptr )
 573         throw lang::DisposedException();
 574
 575     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 576     const sal_uInt16 nLayerCount = rLayerAdmin.GetLayerCount();
 577
 578     uno::Sequence< OUString > aSeq( nLayerCount );
 579
 580     OUString* pStrings = aSeq.getArray();
 581
 582     for( sal_uInt16 nLayer = 0; nLayer < nLayerCount; nLayer++ )
 583     {
 584         SdrLayer* pLayer = rLayerAdmin.GetLayer( nLayer );
 585         if( pLayer )
 586             *pStrings++ = pLayer->GetName();
 587     }
 588
 589     return aSeq;
 590 }
 591
 592 sal_Bool SAL_CALL SdLayerManager::hasByName( const OUString& aName )
 593 {
 594     SolarMutexGuard aGuard;
 595
 596     if( mpModel == nullptr )
 597         throw lang::DisposedException();
 598
 599     SdrLayerAdmin& rLayerAdmin = mpModel->mpDoc->GetLayerAdmin();
 600
 601     return nullptr != rLayerAdmin.GetLayer(aName);
 602 }
 603
 604 // XElementAccess
 605 uno::Type SAL_CALL SdLayerManager::getElementType()
 606 {
 607     return cppu::UnoType<drawing::XLayer>::get();
 608 }
 609
 610 sal_Bool SAL_CALL SdLayerManager::hasElements()
 611 {
 612     return getCount() > 0;
 613 }
 614
 615 /**
 616  * If something was changed at the layers, this methods takes care that the
 617  * changes are made visible in sdbcx::View.
 618  */
 619 void SdLayerManager::UpdateLayerView() const throw()
 620 {
 621     if(!mpModel->mpDocShell)
 622         return;
 623
 624     ::sd::DrawViewShell* pDrViewSh = dynamic_cast< ::sd::DrawViewShell* >( mpModel->mpDocShell->GetViewShell());
 625
 626     if(pDrViewSh)
 627     {
 628         bool bLayerMode = pDrViewSh->IsLayerModeActive();
 629         pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), !bLayerMode);
 630         pDrViewSh->ChangeEditMode(pDrViewSh->GetEditMode(), bLayerMode);
 631     }
 632
 633     mpModel->mpDoc->SetChanged();
 634 }
 635
 636 /** */
 637 ::sd::View* SdLayerManager::GetView() const throw()
 638 {
 639     if( mpModel->mpDocShell )
 640     {
 641         ::sd::ViewShell* pViewSh = mpModel->mpDocShell->GetViewShell();
 642         if(pViewSh)
 643             return pViewSh->GetView();
 644     }
 645     return nullptr;
 646 }
 647
 648 namespace
 649 {
 650 /** Compare two pointers to <type>SdrLayer</type> objects.
 651     @param xRef
 652         The implementing SdLayer class provides the first pointer by the
 653         <member>SdLayer::GetSdrLayer</member> method.
 654     @param pSearchData
 655         This void pointer is the second pointer to an <type>SdrLayer</type>
 656         object.
 657     @return
 658         Return </True> if both pointers point to the same object.
 659 */
 660 bool compare_layers (const uno::WeakReference<uno::XInterface>& xRef, void const * pSearchData)
 661 {
 662     uno::Reference<uno::XInterface> xLayer (xRef);
 663     if (xLayer.is())
 664     {
 665         SdLayer* pSdLayer = SdLayer::getImplementation (xRef);
 666         if (pSdLayer != nullptr)
 667         {
 668             SdrLayer* pSdrLayer = pSdLayer->GetSdrLayer ();
 669             if (pSdrLayer == static_cast<SdrLayer const *>(pSearchData))
 670                 return true;
 671         }
 672     }
 673     return false;
 674 }
 675 }
 676
 677 /** Use the <member>mpLayers</member> container of weak references to either
 678     retrieve and return a previously created <type>XLayer</type> object for
 679     the given <type>SdrLayer</type> object or create and remember a new one.
 680 */
 681 uno::Reference<drawing::XLayer> SdLayerManager::GetLayer (SdrLayer* pLayer)
 682 {
 683     uno::WeakReference<uno::XInterface> xRef;
 684     uno::Reference<drawing::XLayer>  xLayer;
 685
 686     // Search existing xLayer for the given pLayer.
 687     if (mpLayers->findRef (xRef, static_cast<void*>(pLayer), compare_layers))
 688         xLayer.set(xRef, uno::UNO_QUERY);
 689
 690     // Create the xLayer if necessary.
 691     if ( ! xLayer.is())
 692     {
 693         xLayer = new SdLayer (this, pLayer);
 694
 695         // Remember the new xLayer for future calls.
 696         uno::WeakReference<uno::XInterface> wRef(xLayer);
 697         mpLayers->insert(wRef);
 698     }
 699
 700     return xLayer;
 701 }
 702
 703 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */