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