1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_toolkit.hxx" 30 #include <com/sun/star/awt/tree/XMutableTreeDataModel.hpp> 31 #include <com/sun/star/lang/XServiceInfo.hpp> 32 #include <com/sun/star/lang/XUnoTunnel.hpp> 33 #include <cppuhelper/implbase2.hxx> 34 #include <cppuhelper/implbase3.hxx> 35 #include <rtl/ref.hxx> 36 #include <toolkit/helper/mutexandbroadcasthelper.hxx> 37 #include <toolkit/helper/servicenames.hxx> 38 39 using ::rtl::OUString; 40 using namespace ::com::sun::star; 41 using namespace ::com::sun::star::uno; 42 using namespace ::com::sun::star::awt; 43 using namespace ::com::sun::star::awt::tree; 44 using namespace ::com::sun::star::lang; 45 46 namespace toolkit 47 { 48 49 enum broadcast_type { nodes_changed, nodes_inserted, nodes_removed, structure_changed }; 50 51 class MutableTreeNode; 52 class MutableTreeDataModel; 53 54 typedef rtl::Reference< MutableTreeNode > MutableTreeNodeRef; 55 typedef std::vector< MutableTreeNodeRef > TreeNodeVector; 56 typedef rtl::Reference< MutableTreeDataModel > MutableTreeDataModelRef; 57 58 static void implThrowIllegalArgumentException() throw( IllegalArgumentException ) 59 { 60 throw IllegalArgumentException(); 61 } 62 63 class MutableTreeDataModel : public ::cppu::WeakAggImplHelper2< XMutableTreeDataModel, XServiceInfo >, 64 public MutexAndBroadcastHelper 65 { 66 public: 67 MutableTreeDataModel(); 68 virtual ~MutableTreeDataModel(); 69 70 void broadcast( broadcast_type eType, const Reference< XTreeNode >& xParentNode, const Reference< XTreeNode >* pNodes, sal_Int32 nNodes ); 71 72 // XMutableTreeDataModel 73 virtual ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XMutableTreeNode > SAL_CALL createNode( const ::com::sun::star::uno::Any& DisplayValue, ::sal_Bool ChildsOnDemand ) throw (::com::sun::star::uno::RuntimeException); 74 virtual void SAL_CALL setRoot( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XMutableTreeNode >& RootNode ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException); 75 76 // XTreeDataModel 77 virtual ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeNode > SAL_CALL getRoot( ) throw (::com::sun::star::uno::RuntimeException); 78 virtual void SAL_CALL addTreeDataModelListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeDataModelListener >& Listener ) throw (::com::sun::star::uno::RuntimeException); 79 virtual void SAL_CALL removeTreeDataModelListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeDataModelListener >& Listener ) throw (::com::sun::star::uno::RuntimeException); 80 81 // XComponent 82 virtual void SAL_CALL dispose( ) throw (RuntimeException); 83 virtual void SAL_CALL addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException); 84 virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& aListener ) throw (RuntimeException); 85 86 // XServiceInfo 87 virtual OUString SAL_CALL getImplementationName( ) throw (RuntimeException); 88 virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (RuntimeException); 89 virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) throw (RuntimeException); 90 91 private: 92 bool mbDisposed; 93 Reference< XTreeNode > mxRootNode; 94 }; 95 96 class MutableTreeNode: public ::cppu::WeakAggImplHelper2< XMutableTreeNode, XServiceInfo > 97 { 98 friend class MutableTreeDataModel; 99 100 public: 101 MutableTreeNode( const MutableTreeDataModelRef& xModel, const Any& rValue, sal_Bool bChildsOnDemand ); 102 virtual ~MutableTreeNode(); 103 104 void setParent( MutableTreeNode* pParent ); 105 void broadcast_changes(); 106 void broadcast_changes(const Reference< XTreeNode >& xNode, bool bNew); 107 108 // XMutableTreeNode 109 virtual ::com::sun::star::uno::Any SAL_CALL getDataValue() throw (::com::sun::star::uno::RuntimeException); 110 virtual void SAL_CALL setDataValue( const ::com::sun::star::uno::Any& _datavalue ) throw (::com::sun::star::uno::RuntimeException); 111 virtual void SAL_CALL appendChild( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XMutableTreeNode >& ChildNode ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException); 112 virtual void SAL_CALL insertChildByIndex( ::sal_Int32 Index, const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XMutableTreeNode >& ChildNode ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException); 113 virtual void SAL_CALL removeChildByIndex( ::sal_Int32 Index ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException); 114 virtual void SAL_CALL setHasChildrenOnDemand( ::sal_Bool ChildrenOnDemand ) throw (::com::sun::star::uno::RuntimeException); 115 virtual void SAL_CALL setDisplayValue( const ::com::sun::star::uno::Any& Value ) throw (::com::sun::star::uno::RuntimeException); 116 virtual void SAL_CALL setNodeGraphicURL( const ::rtl::OUString& URL ) throw (::com::sun::star::uno::RuntimeException); 117 virtual void SAL_CALL setExpandedGraphicURL( const ::rtl::OUString& URL ) throw (::com::sun::star::uno::RuntimeException); 118 virtual void SAL_CALL setCollapsedGraphicURL( const ::rtl::OUString& URL ) throw (::com::sun::star::uno::RuntimeException); 119 120 // XTreeNode 121 virtual ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeNode > SAL_CALL getChildAt( ::sal_Int32 Index ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException); 122 virtual ::sal_Int32 SAL_CALL getChildCount( ) throw (::com::sun::star::uno::RuntimeException); 123 virtual ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeNode > SAL_CALL getParent( ) throw (::com::sun::star::uno::RuntimeException); 124 virtual ::sal_Int32 SAL_CALL getIndex( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::tree::XTreeNode >& Node ) throw (::com::sun::star::uno::RuntimeException); 125 virtual ::sal_Bool SAL_CALL hasChildrenOnDemand( ) throw (::com::sun::star::uno::RuntimeException); 126 virtual ::com::sun::star::uno::Any SAL_CALL getDisplayValue( ) throw (::com::sun::star::uno::RuntimeException); 127 virtual ::rtl::OUString SAL_CALL getNodeGraphicURL( ) throw (::com::sun::star::uno::RuntimeException); 128 virtual ::rtl::OUString SAL_CALL getExpandedGraphicURL( ) throw (::com::sun::star::uno::RuntimeException); 129 virtual ::rtl::OUString SAL_CALL getCollapsedGraphicURL( ) throw (::com::sun::star::uno::RuntimeException); 130 131 // XServiceInfo 132 virtual OUString SAL_CALL getImplementationName( ) throw (RuntimeException); 133 virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (RuntimeException); 134 virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) throw (RuntimeException); 135 136 static MutableTreeNode* getImplementation( const Reference< XTreeNode >& xNode, bool bThrows ) throw (IllegalArgumentException); 137 Reference< XTreeNode > getReference( MutableTreeNode* pNode ) 138 { 139 return Reference< XTreeNode >( pNode ); 140 } 141 142 private: 143 TreeNodeVector maChilds; 144 Any maDisplayValue; 145 Any maDataValue; 146 sal_Bool mbHasChildsOnDemand; 147 ::osl::Mutex maMutex; 148 MutableTreeNode* mpParent; 149 MutableTreeDataModelRef mxModel; 150 OUString maNodeGraphicURL; 151 OUString maExpandedGraphicURL; 152 OUString maCollapsedGraphicURL; 153 bool mbIsInserted; 154 }; 155 156 /////////////////////////////////////////////////////////////////////// 157 // class MutableTreeDataModel 158 /////////////////////////////////////////////////////////////////////// 159 160 MutableTreeDataModel::MutableTreeDataModel() 161 : mbDisposed( false ) 162 { 163 } 164 165 //--------------------------------------------------------------------- 166 167 MutableTreeDataModel::~MutableTreeDataModel() 168 { 169 } 170 171 //--------------------------------------------------------------------- 172 173 void MutableTreeDataModel::broadcast( broadcast_type eType, const Reference< XTreeNode >& xParentNode, const Reference< XTreeNode >* pNodes, sal_Int32 nNodes ) 174 { 175 ::cppu::OInterfaceContainerHelper* pIter = BrdcstHelper.getContainer( XTreeDataModelListener::static_type() ); 176 if( pIter ) 177 { 178 Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) ); 179 const Sequence< Reference< XTreeNode > > aNodes( pNodes, nNodes ); 180 TreeDataModelEvent aEvent( xSource, aNodes, xParentNode ); 181 182 ::cppu::OInterfaceIteratorHelper aListIter(*pIter); 183 while(aListIter.hasMoreElements()) 184 { 185 XTreeDataModelListener* pListener = static_cast<XTreeDataModelListener*>(aListIter.next()); 186 switch( eType ) 187 { 188 case nodes_changed: pListener->treeNodesChanged(aEvent); break; 189 case nodes_inserted: pListener->treeNodesInserted(aEvent); break; 190 case nodes_removed: pListener->treeNodesRemoved(aEvent); break; 191 case structure_changed: pListener->treeStructureChanged(aEvent); break; 192 } 193 } 194 } 195 } 196 197 //--------------------------------------------------------------------- 198 // XMutableTreeDataModel 199 //--------------------------------------------------------------------- 200 201 Reference< XMutableTreeNode > SAL_CALL MutableTreeDataModel::createNode( const Any& aValue, sal_Bool bChildsOnDemand ) throw (RuntimeException) 202 { 203 return new MutableTreeNode( this, aValue, bChildsOnDemand ); 204 } 205 206 //--------------------------------------------------------------------- 207 208 void SAL_CALL MutableTreeDataModel::setRoot( const Reference< XMutableTreeNode >& xNode ) throw (IllegalArgumentException, RuntimeException) 209 { 210 if( !xNode.is() ) 211 throw IllegalArgumentException(); 212 213 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 214 if( xNode != mxRootNode ) 215 { 216 if( mxRootNode.is() ) 217 { 218 MutableTreeNodeRef xOldImpl( dynamic_cast< MutableTreeNode* >( mxRootNode.get() ) ); 219 if( xOldImpl.is() ) 220 xOldImpl->mbIsInserted = false; 221 } 222 223 MutableTreeNodeRef xImpl( dynamic_cast< MutableTreeNode* >( xNode.get() ) ); 224 if( !xImpl.is() || xImpl->mbIsInserted ) 225 throw IllegalArgumentException(); 226 227 xImpl->mbIsInserted = true; 228 mxRootNode.set(xImpl.get()); 229 230 Reference< XTreeNode > xParentNode; 231 broadcast( structure_changed, xParentNode, &mxRootNode, 1 ); 232 } 233 } 234 235 //--------------------------------------------------------------------- 236 // XTreeDataModel 237 //--------------------------------------------------------------------- 238 239 Reference< XTreeNode > SAL_CALL MutableTreeDataModel::getRoot( ) throw (RuntimeException) 240 { 241 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 242 return mxRootNode; 243 } 244 245 //--------------------------------------------------------------------- 246 247 void SAL_CALL MutableTreeDataModel::addTreeDataModelListener( const Reference< XTreeDataModelListener >& xListener ) throw (RuntimeException) 248 { 249 BrdcstHelper.addListener( XTreeDataModelListener::static_type(), xListener ); 250 } 251 252 //--------------------------------------------------------------------- 253 254 void SAL_CALL MutableTreeDataModel::removeTreeDataModelListener( const Reference< XTreeDataModelListener >& xListener ) throw (RuntimeException) 255 { 256 BrdcstHelper.removeListener( XTreeDataModelListener::static_type(), xListener ); 257 } 258 259 //--------------------------------------------------------------------- 260 // XComponent 261 //--------------------------------------------------------------------- 262 263 void SAL_CALL MutableTreeDataModel::dispose() throw (RuntimeException) 264 { 265 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 266 267 if( !mbDisposed ) 268 { 269 mbDisposed = true; 270 ::com::sun::star::lang::EventObject aEvent; 271 aEvent.Source.set( static_cast< ::cppu::OWeakObject* >( this ) ); 272 BrdcstHelper.aLC.disposeAndClear( aEvent ); 273 } 274 } 275 276 //--------------------------------------------------------------------- 277 278 void SAL_CALL MutableTreeDataModel::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException) 279 { 280 BrdcstHelper.addListener( XEventListener::static_type(), xListener ); 281 } 282 283 //--------------------------------------------------------------------- 284 285 void SAL_CALL MutableTreeDataModel::removeEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException) 286 { 287 BrdcstHelper.removeListener( XEventListener::static_type(), xListener ); 288 } 289 290 //--------------------------------------------------------------------- 291 // XServiceInfo 292 //--------------------------------------------------------------------- 293 294 OUString SAL_CALL MutableTreeDataModel::getImplementationName( ) throw (RuntimeException) 295 { 296 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 297 static const OUString aImplName( RTL_CONSTASCII_USTRINGPARAM( "toolkit.MutableTreeDataModel" ) ); 298 return aImplName; 299 } 300 301 //--------------------------------------------------------------------- 302 303 sal_Bool SAL_CALL MutableTreeDataModel::supportsService( const OUString& ServiceName ) throw (RuntimeException) 304 { 305 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 306 return ServiceName.equalsAscii( szServiceName_MutableTreeDataModel ); 307 } 308 309 //--------------------------------------------------------------------- 310 311 Sequence< OUString > SAL_CALL MutableTreeDataModel::getSupportedServiceNames( ) throw (RuntimeException) 312 { 313 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); 314 static const OUString aServiceName( OUString::createFromAscii( szServiceName_MutableTreeDataModel ) ); 315 static const Sequence< OUString > aSeq( &aServiceName, 1 ); 316 return aSeq; 317 } 318 319 /////////////////////////////////////////////////////////////////////// 320 // class MutabelTreeNode 321 /////////////////////////////////////////////////////////////////////// 322 323 MutableTreeNode::MutableTreeNode( const MutableTreeDataModelRef& xModel, const Any& rValue, sal_Bool bChildsOnDemand ) 324 : maDisplayValue( rValue ) 325 , mbHasChildsOnDemand( bChildsOnDemand ) 326 , mpParent( 0 ) 327 , mxModel( xModel ) 328 , mbIsInserted( false ) 329 { 330 } 331 332 //--------------------------------------------------------------------- 333 334 MutableTreeNode::~MutableTreeNode() 335 { 336 TreeNodeVector::iterator aIter( maChilds.begin() ); 337 while( aIter != maChilds.end() ) 338 (*aIter++)->setParent(0); 339 } 340 341 //--------------------------------------------------------------------- 342 343 void MutableTreeNode::setParent( MutableTreeNode* pParent ) 344 { 345 mpParent = pParent; 346 } 347 348 //--------------------------------------------------------------------- 349 350 MutableTreeNode* MutableTreeNode::getImplementation( const Reference< XTreeNode >& xNode, bool bThrows ) throw (IllegalArgumentException) 351 { 352 MutableTreeNode* pImpl = dynamic_cast< MutableTreeNode* >( xNode.get() ); 353 if( bThrows && !pImpl ) 354 implThrowIllegalArgumentException(); 355 356 return pImpl; 357 } 358 359 //--------------------------------------------------------------------- 360 361 void MutableTreeNode::broadcast_changes() 362 { 363 if( mxModel.is() ) 364 { 365 Reference< XTreeNode > xParent( getReference( mpParent ) ); 366 Reference< XTreeNode > xNode( getReference( this ) ); 367 mxModel->broadcast( nodes_changed, xParent, &xNode, 1 ); 368 } 369 } 370 371 //--------------------------------------------------------------------- 372 373 void MutableTreeNode::broadcast_changes(const Reference< XTreeNode >& xNode, bool bNew) 374 { 375 if( mxModel.is() ) 376 { 377 Reference< XTreeNode > xParent( getReference( this ) ); 378 mxModel->broadcast( bNew ? nodes_inserted : nodes_removed, xParent, &xNode, 1 ); 379 } 380 } 381 382 //--------------------------------------------------------------------- 383 // XMutableTreeNode 384 //--------------------------------------------------------------------- 385 386 Any SAL_CALL MutableTreeNode::getDataValue() throw (RuntimeException) 387 { 388 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 389 return maDataValue; 390 } 391 392 //--------------------------------------------------------------------- 393 394 void SAL_CALL MutableTreeNode::setDataValue( const Any& _datavalue ) throw (RuntimeException) 395 { 396 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 397 maDataValue = _datavalue; 398 } 399 400 //--------------------------------------------------------------------- 401 402 void SAL_CALL MutableTreeNode::appendChild( const Reference< XMutableTreeNode >& xChildNode ) throw (IllegalArgumentException, RuntimeException) 403 { 404 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 405 Reference< XTreeNode > xNode( xChildNode.get() ); 406 MutableTreeNodeRef xImpl( dynamic_cast< MutableTreeNode* >( xNode.get() ) ); 407 408 if( !xImpl.is() || xImpl->mbIsInserted || (this == xImpl.get()) ) 409 throw IllegalArgumentException(); 410 411 maChilds.push_back( xImpl ); 412 xImpl->setParent(this); 413 xImpl->mbIsInserted = true; 414 415 broadcast_changes( xNode, true ); 416 } 417 418 //--------------------------------------------------------------------- 419 420 void SAL_CALL MutableTreeNode::insertChildByIndex( sal_Int32 nChildIndex, const Reference< XMutableTreeNode >& xChildNode ) throw (IllegalArgumentException, IndexOutOfBoundsException, RuntimeException) 421 { 422 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 423 424 if( (nChildIndex < 0) || (nChildIndex > (sal_Int32)maChilds.size()) ) 425 throw IndexOutOfBoundsException(); 426 427 Reference< XTreeNode > xNode( xChildNode.get() ); 428 MutableTreeNodeRef xImpl( dynamic_cast< MutableTreeNode* >( xNode.get() ) ); 429 if( !xImpl.is() || xImpl->mbIsInserted || (this == xImpl.get()) ) 430 throw IllegalArgumentException(); 431 432 xImpl->mbIsInserted = true; 433 434 TreeNodeVector::iterator aIter( maChilds.begin() ); 435 while( (nChildIndex-- > 0) && (aIter != maChilds.end()) ) 436 aIter++; 437 438 maChilds.insert( aIter, xImpl ); 439 xImpl->setParent( this ); 440 441 broadcast_changes( xNode, true ); 442 } 443 444 //--------------------------------------------------------------------- 445 446 void SAL_CALL MutableTreeNode::removeChildByIndex( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException) 447 { 448 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 449 450 MutableTreeNodeRef xImpl; 451 452 if( (nChildIndex >= 0) && (nChildIndex < (sal_Int32)maChilds.size()) ) 453 { 454 TreeNodeVector::iterator aIter( maChilds.begin() ); 455 while( nChildIndex-- && (aIter != maChilds.end()) ) 456 aIter++; 457 458 if( aIter != maChilds.end() ) 459 { 460 xImpl = (*aIter); 461 maChilds.erase( aIter ); 462 } 463 } 464 465 if( !xImpl.is() ) 466 throw IndexOutOfBoundsException(); 467 468 xImpl->setParent(0); 469 xImpl->mbIsInserted = false; 470 471 broadcast_changes( getReference( xImpl.get() ), false ); 472 } 473 474 //--------------------------------------------------------------------- 475 476 void SAL_CALL MutableTreeNode::setHasChildrenOnDemand( sal_Bool bChildsOnDemand ) throw (RuntimeException) 477 { 478 bool bChanged; 479 480 { 481 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 482 bChanged = mbHasChildsOnDemand != bChildsOnDemand; 483 mbHasChildsOnDemand = bChildsOnDemand; 484 } 485 486 if( bChanged ) 487 broadcast_changes(); 488 } 489 490 //--------------------------------------------------------------------- 491 492 void SAL_CALL MutableTreeNode::setDisplayValue( const Any& aValue ) throw (RuntimeException) 493 { 494 { 495 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 496 maDisplayValue = aValue; 497 } 498 499 broadcast_changes(); 500 } 501 502 //--------------------------------------------------------------------- 503 504 void SAL_CALL MutableTreeNode::setNodeGraphicURL( const OUString& rURL ) throw (RuntimeException) 505 { 506 bool bChanged; 507 508 { 509 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 510 bChanged = maNodeGraphicURL != rURL; 511 maNodeGraphicURL = rURL; 512 } 513 514 if( bChanged ) 515 broadcast_changes(); 516 } 517 518 //--------------------------------------------------------------------- 519 520 void SAL_CALL MutableTreeNode::setExpandedGraphicURL( const OUString& rURL ) throw (RuntimeException) 521 { 522 bool bChanged; 523 524 { 525 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 526 bChanged = maExpandedGraphicURL != rURL; 527 maExpandedGraphicURL = rURL; 528 } 529 530 if( bChanged ) 531 broadcast_changes(); 532 } 533 534 //--------------------------------------------------------------------- 535 536 void SAL_CALL MutableTreeNode::setCollapsedGraphicURL( const OUString& rURL ) throw (RuntimeException) 537 { 538 bool bChanged; 539 540 { 541 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 542 bChanged = maCollapsedGraphicURL != rURL; 543 maCollapsedGraphicURL = rURL; 544 } 545 546 if( bChanged ) 547 broadcast_changes(); 548 } 549 550 //--------------------------------------------------------------------- 551 // XTreeNode 552 //--------------------------------------------------------------------- 553 554 Reference< XTreeNode > SAL_CALL MutableTreeNode::getChildAt( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException,RuntimeException) 555 { 556 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 557 558 if( (nChildIndex < 0) || (nChildIndex >= (sal_Int32)maChilds.size()) ) 559 throw IndexOutOfBoundsException(); 560 return getReference( maChilds[nChildIndex].get() ); 561 } 562 563 //--------------------------------------------------------------------- 564 565 sal_Int32 SAL_CALL MutableTreeNode::getChildCount( ) throw (RuntimeException) 566 { 567 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 568 return (sal_Int32)maChilds.size(); 569 } 570 571 //--------------------------------------------------------------------- 572 573 Reference< XTreeNode > SAL_CALL MutableTreeNode::getParent( ) throw (RuntimeException) 574 { 575 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 576 return getReference( mpParent ); 577 } 578 579 //--------------------------------------------------------------------- 580 581 sal_Int32 SAL_CALL MutableTreeNode::getIndex( const Reference< XTreeNode >& xNode ) throw (RuntimeException) 582 { 583 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 584 585 MutableTreeNodeRef xImpl( MutableTreeNode::getImplementation( xNode, false ) ); 586 if( xImpl.is() ) 587 { 588 sal_Int32 nChildCount = maChilds.size(); 589 while( nChildCount-- ) 590 { 591 if( maChilds[nChildCount] == xImpl ) 592 return nChildCount; 593 } 594 } 595 596 return -1; 597 } 598 599 //--------------------------------------------------------------------- 600 601 sal_Bool SAL_CALL MutableTreeNode::hasChildrenOnDemand( ) throw (RuntimeException) 602 { 603 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 604 return mbHasChildsOnDemand; 605 } 606 607 //--------------------------------------------------------------------- 608 609 Any SAL_CALL MutableTreeNode::getDisplayValue( ) throw (RuntimeException) 610 { 611 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 612 return maDisplayValue; 613 } 614 615 //--------------------------------------------------------------------- 616 617 OUString SAL_CALL MutableTreeNode::getNodeGraphicURL( ) throw (RuntimeException) 618 { 619 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 620 return maNodeGraphicURL; 621 } 622 623 //--------------------------------------------------------------------- 624 625 OUString SAL_CALL MutableTreeNode::getExpandedGraphicURL( ) throw (RuntimeException) 626 { 627 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 628 return maExpandedGraphicURL; 629 } 630 631 //--------------------------------------------------------------------- 632 633 OUString SAL_CALL MutableTreeNode::getCollapsedGraphicURL( ) throw (RuntimeException) 634 { 635 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 636 return maCollapsedGraphicURL; 637 } 638 639 //--------------------------------------------------------------------- 640 // XServiceInfo 641 //--------------------------------------------------------------------- 642 643 OUString SAL_CALL MutableTreeNode::getImplementationName( ) throw (RuntimeException) 644 { 645 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 646 static const OUString aImplName( RTL_CONSTASCII_USTRINGPARAM( "toolkit.MutableTreeNode" ) ); 647 return aImplName; 648 } 649 650 //--------------------------------------------------------------------- 651 652 sal_Bool SAL_CALL MutableTreeNode::supportsService( const OUString& ServiceName ) throw (RuntimeException) 653 { 654 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 655 return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.awt.tree.MutableTreeNode" ) ); 656 } 657 658 //--------------------------------------------------------------------- 659 660 Sequence< OUString > SAL_CALL MutableTreeNode::getSupportedServiceNames( ) throw (RuntimeException) 661 { 662 ::osl::Guard< ::osl::Mutex > aGuard( maMutex ); 663 static const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.tree.MutableTreeNode" ) ); 664 static const Sequence< OUString > aSeq( &aServiceName, 1 ); 665 return aSeq; 666 } 667 668 } 669 670 Reference< XInterface > SAL_CALL MutableTreeDataModel_CreateInstance( const Reference< XMultiServiceFactory >& ) 671 { 672 return Reference < XInterface >( ( ::cppu::OWeakObject* ) new ::toolkit::MutableTreeDataModel ); 673 } 674