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