svtools/source/uno/treecontrolpeer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: treecontrolpeer.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #define _SVTREEBX_CXX
  35 #include <tools/debug.hxx>
  36 #include <com/sun/star/lang/XServiceInfo.hpp>
  37 #include <com/sun/star/lang/DisposedException.hpp>
  38 #include <com/sun/star/view/SelectionType.hpp>
  39 #include <toolkit/helper/property.hxx>
  40
  41 #include <com/sun/star/awt/tree/XMutableTreeNode.hpp>
  42 #include <treecontrolpeer.hxx>
  43 #include <comphelper/processfactory.hxx>
  44
  45 #include <rtl/ref.hxx>
  46 #include <vcl/graph.hxx>
  47 #include <svtools/svtreebx.hxx>
  48
  49 #include <map>
  50
  51 using ::rtl::OUString;
  52 using namespace ::com::sun::star;
  53 using namespace ::com::sun::star::uno;
  54 using namespace ::com::sun::star::lang;
  55 using namespace ::com::sun::star::awt::tree;
  56 using namespace ::com::sun::star::beans;
  57 using namespace ::com::sun::star::view;
  58 using namespace ::com::sun::star::container;
  59 using namespace ::com::sun::star::util;
  60 using namespace ::com::sun::star::graphic;
  61
  62 #define O(x) OUString( RTL_CONSTASCII_USTRINGPARAM(x) )
  63
  64 struct LockGuard
  65 {
  66 public:
  67     LockGuard( sal_Int32& rLock )
  68     : mrLock( rLock )
  69     {
  70         rLock++;
  71     }
  72
  73     ~LockGuard()
  74     {
  75         mrLock--;
  76     }
  77
  78     sal_Int32& mrLock;
  79 };
  80
  81 // --------------------------------------------------------------------
  82
  83 class ImplGraphicItem : public SvLBoxBmp
  84 {
  85 public:
  86     ImplGraphicItem( SvLBoxEntry* pEntry, USHORT nFlags, Image& aImage ) : SvLBoxBmp( pEntry, nFlags, aImage ) {}
  87
  88     OUString msGraphicURL;
  89 };
  90
  91 // --------------------------------------------------------------------
  92
  93 class ImplContextGraphicItem : public SvLBoxContextBmp
  94 {
  95 public:
  96     ImplContextGraphicItem( SvLBoxEntry* pEntry,USHORT nFlags,Image& rI1,Image& rI2, USHORT nEntryFlagsBmp1)
  97         : SvLBoxContextBmp( pEntry, nFlags, rI1, rI2, nEntryFlagsBmp1 ) {}
  98
  99     OUString msExpandedGraphicURL;
 100     OUString msCollapsedGraphicURL;
 101 };
 102
 103 // --------------------------------------------------------------------
 104
 105 class UnoTreeListBoxImpl : public SvTreeListBox
 106 {
 107 public:
 108     UnoTreeListBoxImpl( TreeControlPeer* pPeer, Window* pParent, WinBits nWinStyle );
 109     ~UnoTreeListBoxImpl();
 110
 111     sal_uInt32 insert( SvLBoxEntry* pEntry,SvLBoxEntry* pParent,ULONG nPos=LIST_APPEND );
 112
 113     virtual void        RequestingChilds( SvLBoxEntry* pParent );
 114
 115     virtual BOOL        EditingEntry( SvLBoxEntry* pEntry, Selection& );
 116     virtual BOOL        EditedEntry( SvLBoxEntry* pEntry, const XubString& rNewText );
 117
 118     DECL_LINK( OnSelectionChangeHdl, UnoTreeListBoxImpl* );
 119     DECL_LINK( OnExpandingHdl, UnoTreeListBoxImpl* );
 120     DECL_LINK( OnExpandedHdl, UnoTreeListBoxImpl* );
 121
 122 private:
 123     rtl::Reference< TreeControlPeer > mxPeer;
 124 };
 125
 126 // --------------------------------------------------------------------
 127
 128 class SVT_DLLPUBLIC UnoTreeListItem : public SvLBoxItem
 129 {
 130 public:
 131                     UnoTreeListItem( SvLBoxEntry* );
 132                     UnoTreeListItem();
 133     virtual                     ~UnoTreeListItem();
 134     virtual USHORT      IsA();
 135     void                        InitViewData( SvLBox*,SvLBoxEntry*,SvViewDataItem* );
 136     OUString            GetText() const;
 137     void                        SetText( const OUString& rText );
 138     Image                       GetImage() const;
 139     void                        SetImage( const Image& rImage );
 140     OUString            GetGraphicURL() const;
 141     void                        SetGraphicURL( const OUString& rGraphicURL );
 142     void                        Paint( const Point&, SvLBox& rDev, USHORT nFlags,SvLBoxEntry* );
 143     SvLBoxItem*         Create() const;
 144     void                        Clone( SvLBoxItem* pSource );
 145
 146 private:
 147     OUString            maText;
 148     OUString            maGraphicURL;
 149     Image                       maImage;
 150 };
 151
 152 // --------------------------------------------------------------------
 153
 154 class UnoTreeListEntry : public SvLBoxEntry
 155 {
 156 public:
 157     UnoTreeListEntry( const Reference< XTreeNode >& xNode, TreeControlPeer* pPeer );
 158     virtual ~UnoTreeListEntry();
 159
 160     Reference< XTreeNode > mxNode;
 161     TreeControlPeer* mpPeer;
 162 };
 163
 164 // --------------------------------------------------------------------
 165
 166 class TreeNodeMap : public std::map< Reference< XTreeNode >, UnoTreeListEntry* >
 167 {
 168 };
 169
 170 // --------------------------------------------------------------------
 171
 172 TreeControlPeer::TreeControlPeer()
 173 : maSelectionListeners( *this )
 174 , maTreeExpansionListeners( *this )
 175 , maTreeEditListeners( *this )
 176 , mpTreeImpl( 0 )
 177 , mnEditLock( 0 )
 178 , mpTreeNodeMap( 0 )
 179 {
 180 }
 181
 182 // --------------------------------------------------------------------
 183
 184 TreeControlPeer::~TreeControlPeer()
 185 {
 186     if( mpTreeImpl )
 187         mpTreeImpl->Clear();
 188     delete mpTreeNodeMap;
 189 }
 190
 191 // --------------------------------------------------------------------
 192
 193 void TreeControlPeer::addEntry( UnoTreeListEntry* pEntry )
 194 {
 195     if( pEntry && pEntry->mxNode.is() )
 196     {
 197         if( !mpTreeNodeMap )
 198         {
 199             mpTreeNodeMap = new TreeNodeMap();
 200         }
 201
 202         (*mpTreeNodeMap)[ pEntry->mxNode ] = pEntry;
 203     }
 204 }
 205
 206 // --------------------------------------------------------------------
 207
 208 void TreeControlPeer::removeEntry( UnoTreeListEntry* pEntry )
 209 {
 210     if( mpTreeNodeMap && pEntry && pEntry->mxNode.is() )
 211     {
 212         TreeNodeMap::iterator aIter( mpTreeNodeMap->find( pEntry->mxNode ) );
 213         if( aIter != mpTreeNodeMap->end() )
 214             mpTreeNodeMap->erase( aIter );
 215     }
 216 }
 217
 218 // --------------------------------------------------------------------
 219
 220 UnoTreeListEntry* TreeControlPeer::getEntry( const Reference< XTreeNode >& xNode, bool bThrow /* = true */ ) throw( IllegalArgumentException )
 221 {
 222     if( mpTreeNodeMap )
 223     {
 224         TreeNodeMap::iterator aIter( mpTreeNodeMap->find( xNode ) );
 225         if( aIter != mpTreeNodeMap->end() )
 226             return (*aIter).second;
 227     }
 228
 229     if( bThrow )
 230         throw IllegalArgumentException();
 231
 232     return 0;
 233 }
 234
 235 // --------------------------------------------------------------------
 236
 237 Window* TreeControlPeer::createVclControl( Window* pParent, sal_Int64 nWinStyle )
 238 {
 239     mpTreeImpl = new UnoTreeListBoxImpl( this, pParent, nWinStyle );
 240     return mpTreeImpl;
 241 }
 242
 243 // --------------------------------------------------------------------
 244
 245 /** called from the UnoTreeListBoxImpl when it gets deleted */
 246 void TreeControlPeer::disposeControl()
 247 {
 248     delete mpTreeNodeMap;
 249     mpTreeNodeMap = 0;
 250     mpTreeImpl = 0;
 251 }
 252
 253 // --------------------------------------------------------------------
 254
 255 void TreeControlPeer::SetWindow( Window* pWindow )
 256 {
 257     VCLXWindow::SetWindow( pWindow );
 258 }
 259
 260 // --------------------------------------------------------------------
 261
 262 UnoTreeListEntry* TreeControlPeer::createEntry( const Reference< XTreeNode >& xNode, UnoTreeListEntry* pParent, ULONG nPos /* = LIST_APPEND */ )
 263 {
 264     UnoTreeListEntry* pEntry = 0;
 265     if( mpTreeImpl )
 266     {
 267         Image aImage;
 268         pEntry = new UnoTreeListEntry( xNode, this );
 269         ImplContextGraphicItem* pContextBmp= new ImplContextGraphicItem( pEntry,0, aImage, aImage, SVLISTENTRYFLAG_EXPANDED );
 270
 271         pEntry->AddItem( pContextBmp );
 272
 273         UnoTreeListItem * pUnoItem = new UnoTreeListItem( pEntry );
 274
 275         if( xNode->getNodeGraphicURL().getLength() )
 276         {
 277             pUnoItem->SetGraphicURL( xNode->getNodeGraphicURL() );
 278             Image aNodeImage;
 279             loadImage( xNode->getNodeGraphicURL(), aNodeImage );
 280             pUnoItem->SetImage( aNodeImage );
 281             mpTreeImpl->AdjustEntryHeight( aNodeImage );
 282         }
 283
 284         pEntry->AddItem( pUnoItem );
 285
 286         if( msDefaultExpandedGraphicURL.getLength() )
 287             mpTreeImpl->SetExpandedEntryBmp( pEntry, maDefaultExpandedImage );
 288
 289         if( msDefaultCollapsedGraphicURL.getLength() )
 290             mpTreeImpl->SetCollapsedEntryBmp( pEntry, maDefaultCollapsedImage );
 291
 292         mpTreeImpl->insert( pEntry, pParent, nPos );
 293
 294         updateEntry( pEntry );
 295     }
 296     return pEntry;
 297 }
 298
 299 // --------------------------------------------------------------------
 300
 301 bool TreeControlPeer::updateEntry( UnoTreeListEntry* pEntry )
 302 {
 303     bool bChanged = false;
 304     if( pEntry && pEntry->mxNode.is() && mpTreeImpl )
 305     {
 306         const OUString aValue( getEntryString( pEntry->mxNode->getDisplayValue() ) );
 307         UnoTreeListItem* pUnoItem = dynamic_cast< UnoTreeListItem* >( pEntry->GetItem( 1 ) );
 308         if( pUnoItem )
 309         {
 310             if( aValue != pUnoItem->GetText() )
 311             {
 312                 pUnoItem->SetText( aValue );
 313                 bChanged = true;
 314             }
 315
 316             if( pUnoItem->GetGraphicURL() != pEntry->mxNode->getNodeGraphicURL() )
 317             {
 318                 Image aImage;
 319                 if( loadImage( pEntry->mxNode->getNodeGraphicURL(), aImage ) )
 320                 {
 321                     pUnoItem->SetGraphicURL( pEntry->mxNode->getNodeGraphicURL() );
 322                     pUnoItem->SetImage( aImage );
 323                     mpTreeImpl->AdjustEntryHeight( aImage );
 324                     bChanged = true;
 325                 }
 326             }
 327         }
 328
 329         if( (pEntry->mxNode->hasChildrenOnDemand() == sal_True) != (pEntry->HasChildsOnDemand() == TRUE) )
 330         {
 331             pEntry->EnableChildsOnDemand( pEntry->mxNode->hasChildrenOnDemand() ? TRUE : FALSE );
 332             bChanged = true;
 333         }
 334
 335         ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) );
 336         if( pContextGraphicItem )
 337         {
 338             if( pContextGraphicItem->msExpandedGraphicURL != pEntry->mxNode->getExpandedGraphicURL() )
 339             {
 340                 Image aImage;
 341                 if(     loadImage( pEntry->mxNode->getExpandedGraphicURL(), aImage ) )
 342                 {
 343                     pContextGraphicItem->msExpandedGraphicURL = pEntry->mxNode->getExpandedGraphicURL();
 344                     mpTreeImpl->SetExpandedEntryBmp( pEntry, aImage );
 345                     bChanged = true;
 346                 }
 347             }
 348             if( pContextGraphicItem->msCollapsedGraphicURL != pEntry->mxNode->getCollapsedGraphicURL() )
 349             {
 350                 Image aImage;
 351                 if(     loadImage( pEntry->mxNode->getCollapsedGraphicURL(), aImage ) )
 352                 {
 353                     pContextGraphicItem->msCollapsedGraphicURL = pEntry->mxNode->getCollapsedGraphicURL();
 354                     mpTreeImpl->SetCollapsedEntryBmp( pEntry, aImage );
 355                     bChanged = true;
 356                 }
 357             }
 358         }
 359
 360         if( bChanged )
 361             mpTreeImpl->GetModel()->InvalidateEntry( pEntry );
 362     }
 363
 364     return bChanged;
 365 }
 366
 367 // --------------------------------------------------------------------
 368
 369 void TreeControlPeer::onSelectionChanged()
 370 {
 371     Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 372     EventObject aEvent( xSource );
 373     maSelectionListeners.selectionChanged( aEvent );
 374 }
 375
 376 // --------------------------------------------------------------------
 377
 378 void TreeControlPeer::onRequestChildNodes( const Reference< XTreeNode >& xNode )
 379 {
 380     try
 381     {
 382         Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 383         TreeExpansionEvent aEvent( xSource, xNode );
 384         maTreeExpansionListeners.requestChildNodes( aEvent );
 385     }
 386     catch( Exception& )
 387     {
 388     }
 389 }
 390
 391 // --------------------------------------------------------------------
 392
 393 bool TreeControlPeer::onExpanding( const Reference< XTreeNode >& xNode, bool bExpanding )
 394 {
 395     try
 396     {
 397         Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 398         TreeExpansionEvent aEvent( xSource, xNode );
 399         if( bExpanding )
 400         {
 401             maTreeExpansionListeners.treeExpanding( aEvent );
 402         }
 403         else
 404         {
 405             maTreeExpansionListeners.treeCollapsing( aEvent );
 406         }
 407     }
 408     catch( Exception& )
 409     {
 410         return false;
 411     }
 412     return true;
 413 }
 414
 415 // --------------------------------------------------------------------
 416
 417 void TreeControlPeer::onExpanded( const Reference< XTreeNode >& xNode, bool bExpanding )
 418 {
 419     try
 420     {
 421         Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 422         TreeExpansionEvent aEvent( xSource, xNode );
 423
 424         if( bExpanding )
 425         {
 426             maTreeExpansionListeners.treeExpanded( aEvent );
 427         }
 428         else
 429         {
 430             maTreeExpansionListeners.treeCollapsed( aEvent );
 431         }
 432     }
 433     catch( Exception& )
 434     {
 435     }
 436 }
 437
 438 // --------------------------------------------------------------------
 439
 440 void TreeControlPeer::fillTree( UnoTreeListBoxImpl& rTree, const Reference< XTreeDataModel >& xDataModel )
 441 {
 442     rTree.Clear();
 443
 444     if( xDataModel.is() )
 445     {
 446         Reference< XTreeNode > xRootNode( xDataModel->getRoot() );
 447         if( xRootNode.is() )
 448         {
 449             if( mbIsRootDisplayed )
 450             {
 451                 addNode( rTree, xRootNode, 0 );
 452             }
 453             else
 454             {
 455                 const sal_Int32 nChildCount = xRootNode->getChildCount();
 456                 for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ )
 457                     addNode( rTree, xRootNode->getChildAt( nChild ), 0 );
 458             }
 459         }
 460     }
 461 }
 462
 463 // --------------------------------------------------------------------
 464
 465 void TreeControlPeer::addNode( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xNode, UnoTreeListEntry* pParentEntry )
 466 {
 467     if( xNode.is() )
 468     {
 469         UnoTreeListEntry* pEntry = createEntry( xNode, pParentEntry, LIST_APPEND );
 470         const sal_Int32 nChildCount = xNode->getChildCount();
 471         for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ )
 472             addNode( rTree, xNode->getChildAt( nChild ), pEntry );
 473     }
 474 }
 475
 476 // --------------------------------------------------------------------
 477
 478 UnoTreeListBoxImpl& TreeControlPeer::getTreeListBoxOrThrow() const throw (RuntimeException )
 479 {
 480     if( !mpTreeImpl )
 481         throw DisposedException();
 482     return *mpTreeImpl;
 483 }
 484
 485 // --------------------------------------------------------------------
 486
 487 void TreeControlPeer::ChangeNodesSelection( const Any& rSelection, bool bSelect, bool bSetSelection ) throw( RuntimeException, IllegalArgumentException )
 488 {
 489     ::vos::OGuard aGuard( GetMutex() );
 490
 491     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 492
 493     Reference< XTreeNode > xTempNode;
 494     Sequence< XTreeNode > aTempSeq;
 495
 496     const Reference< XTreeNode > *pNodes = 0;
 497     sal_Int32 nCount = 0;
 498
 499     if( rSelection.hasValue() )
 500     {
 501         switch( rSelection.getValueTypeClass() )
 502         {
 503         case TypeClass_INTERFACE:
 504             {
 505                 rSelection >>= xTempNode;
 506                 if( xTempNode.is() )
 507                 {
 508                     nCount = 1;
 509                     pNodes = &xTempNode;
 510                 }
 511                 break;
 512             }
 513         case TypeClass_SEQUENCE:
 514             {
 515                 if( rSelection.getValueType() == ::getCppuType( (const Sequence< Reference< XTreeNode > > *) 0 ) )
 516                 {
 517                     const Sequence< Reference< XTreeNode > >& rSeq( *(const Sequence< Reference< XTreeNode > > *)rSelection.getValue() );
 518                     nCount = rSeq.getLength();
 519                     if( nCount )
 520                         pNodes = rSeq.getConstArray();
 521                 }
 522                 break;
 523             }
 524         default:
 525             break;
 526         }
 527
 528         if( nCount == 0 )
 529             throw IllegalArgumentException();
 530     }
 531
 532     if( bSetSelection )
 533         rTree.SelectAll( FALSE );
 534
 535     if( pNodes && nCount )
 536     {
 537         while( nCount-- )
 538         {
 539             UnoTreeListEntry* pEntry = getEntry( *pNodes++ );
 540             rTree.Select( pEntry, bSelect ? TRUE : FALSE );
 541         }
 542     }
 543 }
 544
 545 // -------------------------------------------------------------------
 546 // ::com::sun::star::view::XSelectionSupplier
 547 // -------------------------------------------------------------------
 548
 549 sal_Bool SAL_CALL TreeControlPeer::select( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 550 {
 551     ::vos::OGuard aGuard( GetMutex() );
 552     ChangeNodesSelection( rSelection, true, true );
 553     return sal_True;
 554 }
 555
 556 // -------------------------------------------------------------------
 557
 558 Any SAL_CALL TreeControlPeer::getSelection() throw (RuntimeException)
 559 {
 560     ::vos::OGuard aGuard( GetMutex() );
 561
 562     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 563
 564     Any aRet;
 565
 566     ULONG nSelectionCount = rTree.GetSelectionCount();
 567     if( nSelectionCount == 1 )
 568     {
 569         UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 570         if( pEntry && pEntry->mxNode.is() )
 571             aRet <<= pEntry->mxNode;
 572     }
 573     else if( nSelectionCount > 1 )
 574     {
 575         Sequence< Reference< XTreeNode > > aSelection( nSelectionCount );
 576         Reference< XTreeNode >* pNodes = aSelection.getArray();
 577         UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 578         while( pEntry && nSelectionCount )
 579         {
 580             *pNodes++ = pEntry->mxNode;
 581             pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 582             --nSelectionCount;
 583         }
 584
 585         OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 586         aRet <<= aSelection;
 587     }
 588
 589     return aRet;
 590 }
 591
 592 // -------------------------------------------------------------------
 593
 594 void SAL_CALL TreeControlPeer::addSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException)
 595 {
 596     maSelectionListeners.addInterface( xListener );
 597 }
 598
 599 // -------------------------------------------------------------------
 600
 601 void SAL_CALL TreeControlPeer::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException)
 602 {
 603     maSelectionListeners.addInterface( xListener );
 604 }
 605
 606 // -------------------------------------------------------------------
 607 // ::com::sun::star::view::XMultiSelectionSupplier
 608 // -------------------------------------------------------------------
 609
 610 sal_Bool SAL_CALL TreeControlPeer::addSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 611 {
 612     ChangeNodesSelection( rSelection, true, false );
 613     return sal_True;
 614 }
 615
 616 // -------------------------------------------------------------------
 617
 618 void SAL_CALL TreeControlPeer::removeSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 619 {
 620     ChangeNodesSelection( rSelection, false, false );
 621 }
 622
 623 // -------------------------------------------------------------------
 624
 625 void SAL_CALL TreeControlPeer::clearSelection() throw (RuntimeException)
 626 {
 627     ::vos::OGuard aGuard( GetMutex() );
 628     getTreeListBoxOrThrow().SelectAll( FALSE );
 629 }
 630
 631 // -------------------------------------------------------------------
 632
 633 sal_Int32 SAL_CALL TreeControlPeer::getSelectionCount() throw (RuntimeException)
 634 {
 635     ::vos::OGuard aGuard( GetMutex() );
 636     return getTreeListBoxOrThrow().GetSelectionCount();
 637 }
 638
 639 // -------------------------------------------------------------------
 640
 641 class TreeSelectionEnumeration : public ::cppu::WeakImplHelper1< XEnumeration >
 642 {
 643 public:
 644     TreeSelectionEnumeration( std::list< Any >& rSelection );
 645     virtual ::sal_Bool SAL_CALL hasMoreElements() throw (RuntimeException);
 646     virtual Any SAL_CALL nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException);
 647
 648     std::list< Any > maSelection;
 649     std::list< Any >::iterator maIter;
 650 };
 651
 652 // -------------------------------------------------------------------
 653
 654 TreeSelectionEnumeration::TreeSelectionEnumeration( std::list< Any >& rSelection )
 655 {
 656     maSelection.swap( rSelection );
 657     maIter = maSelection.begin();
 658 }
 659
 660 // -------------------------------------------------------------------
 661
 662 ::sal_Bool SAL_CALL TreeSelectionEnumeration::hasMoreElements() throw (RuntimeException)
 663 {
 664     return maIter != maSelection.end();
 665 }
 666
 667 // -------------------------------------------------------------------
 668
 669 Any SAL_CALL TreeSelectionEnumeration::nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException)
 670 {
 671     if( maIter == maSelection.end() )
 672         throw NoSuchElementException();
 673
 674     return (*maIter++);
 675 }
 676
 677 // -------------------------------------------------------------------
 678
 679 Reference< XEnumeration > SAL_CALL TreeControlPeer::createSelectionEnumeration() throw (RuntimeException)
 680 {
 681     ::vos::OGuard aGuard( GetMutex() );
 682
 683     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 684
 685     sal_uInt32 nSelectionCount = rTree.GetSelectionCount();
 686     std::list< Any > aSelection( nSelectionCount );
 687
 688     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 689     while( pEntry && nSelectionCount )
 690     {
 691         aSelection.push_back( Any( pEntry->mxNode ) );
 692         pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 693         --nSelectionCount;
 694     }
 695
 696     OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 697
 698     return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) );
 699 }
 700
 701 // -------------------------------------------------------------------
 702
 703 Reference< XEnumeration > SAL_CALL TreeControlPeer::createReverseSelectionEnumeration() throw (RuntimeException)
 704 {
 705     ::vos::OGuard aGuard( GetMutex() );
 706
 707     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 708
 709     sal_uInt32 nSelectionCount = rTree.GetSelectionCount();
 710     std::list< Any > aSelection;
 711
 712     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 713     while( pEntry && nSelectionCount )
 714     {
 715         aSelection.push_front( Any( pEntry->mxNode ) );
 716         pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 717         --nSelectionCount;
 718     }
 719
 720     OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 721
 722     return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) );
 723 }
 724
 725 // --------------------------------------------------------------------
 726 // ::com::sun::star::awt::XTreeControl
 727 // --------------------------------------------------------------------
 728
 729 OUString SAL_CALL TreeControlPeer::getDefaultExpandedGraphicURL() throw (::com::sun::star::uno::RuntimeException)
 730 {
 731     ::vos::OGuard aGuard( GetMutex() );
 732     return msDefaultExpandedGraphicURL;
 733 }
 734
 735 // --------------------------------------------------------------------
 736
 737 void SAL_CALL TreeControlPeer::setDefaultExpandedGraphicURL( const ::rtl::OUString& sDefaultExpandedGraphicURL ) throw (::com::sun::star::uno::RuntimeException)
 738 {
 739     ::vos::OGuard aGuard( GetMutex() );
 740     if( msDefaultExpandedGraphicURL != sDefaultExpandedGraphicURL )
 741     {
 742         if( sDefaultExpandedGraphicURL.getLength() )
 743             loadImage( sDefaultExpandedGraphicURL, maDefaultExpandedImage );
 744         else
 745             maDefaultExpandedImage = Image();
 746
 747         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 748
 749         SvLBoxEntry* pEntry = rTree.First();
 750         while( pEntry )
 751         {
 752             ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) );
 753             if( pContextGraphicItem )
 754             {
 755                 if( pContextGraphicItem->msExpandedGraphicURL.getLength() == 0 )
 756                     rTree.SetExpandedEntryBmp( pEntry, maDefaultExpandedImage );
 757             }
 758             pEntry = rTree.Next( pEntry );
 759         }
 760
 761         msDefaultExpandedGraphicURL = sDefaultExpandedGraphicURL;
 762     }
 763 }
 764
 765 // --------------------------------------------------------------------
 766
 767 OUString SAL_CALL TreeControlPeer::getDefaultCollapsedGraphicURL() throw (::com::sun::star::uno::RuntimeException)
 768 {
 769     ::vos::OGuard aGuard( GetMutex() );
 770     return msDefaultCollapsedGraphicURL;
 771 }
 772
 773 // --------------------------------------------------------------------
 774
 775 void SAL_CALL TreeControlPeer::setDefaultCollapsedGraphicURL( const ::rtl::OUString& sDefaultCollapsedGraphicURL ) throw (::com::sun::star::uno::RuntimeException)
 776 {
 777     ::vos::OGuard aGuard( GetMutex() );
 778     if( msDefaultCollapsedGraphicURL != sDefaultCollapsedGraphicURL )
 779     {
 780         if( sDefaultCollapsedGraphicURL.getLength() )
 781             loadImage( sDefaultCollapsedGraphicURL, maDefaultCollapsedImage );
 782         else
 783             maDefaultCollapsedImage = Image();
 784
 785         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 786
 787         SvLBoxEntry* pEntry = rTree.First();
 788         while( pEntry )
 789         {
 790             ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) );
 791             if( pContextGraphicItem )
 792             {
 793                 if( pContextGraphicItem->msCollapsedGraphicURL.getLength() == 0 )
 794                     rTree.SetCollapsedEntryBmp( pEntry, maDefaultCollapsedImage );
 795             }
 796             pEntry = rTree.Next( pEntry );
 797         }
 798
 799         msDefaultCollapsedGraphicURL = sDefaultCollapsedGraphicURL;
 800     }
 801 }
 802
 803 // --------------------------------------------------------------------
 804
 805 sal_Bool SAL_CALL TreeControlPeer::isNodeExpanded( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 806 {
 807     ::vos::OGuard aGuard( GetMutex() );
 808
 809     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 810     UnoTreeListEntry* pEntry = getEntry( xNode );
 811     return ( pEntry && rTree.IsExpanded( pEntry ) ) ? sal_True : sal_False;
 812 }
 813
 814 // -------------------------------------------------------------------
 815
 816 sal_Bool SAL_CALL TreeControlPeer::isNodeCollapsed( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 817 {
 818     ::vos::OGuard aGuard( GetMutex() );
 819     return !isNodeExpanded( xNode );
 820 }
 821
 822 // -------------------------------------------------------------------
 823
 824 void SAL_CALL TreeControlPeer::makeNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 825 {
 826     ::vos::OGuard aGuard( GetMutex() );
 827
 828     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 829     UnoTreeListEntry* pEntry = getEntry( xNode );
 830     if( pEntry )
 831         rTree.MakeVisible( pEntry );
 832 }
 833
 834 // -------------------------------------------------------------------
 835
 836 sal_Bool SAL_CALL TreeControlPeer::isNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 837 {
 838     ::vos::OGuard aGuard( GetMutex() );
 839
 840     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 841     UnoTreeListEntry* pEntry = getEntry( xNode );
 842     return ( pEntry && rTree.IsEntryVisible( pEntry ) ) ? sal_True : sal_False;
 843 }
 844
 845 // -------------------------------------------------------------------
 846
 847 void SAL_CALL TreeControlPeer::expandNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 848 {
 849     ::vos::OGuard aGuard( GetMutex() );
 850
 851     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 852     UnoTreeListEntry* pEntry = getEntry( xNode );
 853     if( pEntry )
 854         rTree.Expand( pEntry );
 855 }
 856
 857 // -------------------------------------------------------------------
 858
 859 void SAL_CALL TreeControlPeer::collapseNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 860 {
 861     ::vos::OGuard aGuard( GetMutex() );
 862
 863     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 864     UnoTreeListEntry* pEntry = getEntry( xNode );
 865     if( pEntry )
 866         rTree.Collapse( pEntry );
 867 }
 868
 869 // -------------------------------------------------------------------
 870
 871 void SAL_CALL TreeControlPeer::addTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException)
 872 {
 873     maTreeExpansionListeners.addInterface( xListener );
 874 }
 875
 876 // -------------------------------------------------------------------
 877
 878 void SAL_CALL TreeControlPeer::removeTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException)
 879 {
 880     maTreeExpansionListeners.removeInterface( xListener );
 881 }
 882
 883 // -------------------------------------------------------------------
 884
 885 Reference< XTreeNode > SAL_CALL TreeControlPeer::getNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException)
 886 {
 887     ::vos::OGuard aGuard( GetMutex() );
 888
 889     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 890
 891     Reference< XTreeNode > xNode;
 892
 893     const Point aPos( x, y );
 894     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, TRUE ) );
 895     if( pEntry )
 896         xNode = pEntry->mxNode;
 897
 898     return xNode;
 899 }
 900
 901 // -------------------------------------------------------------------
 902
 903 Reference< XTreeNode > SAL_CALL TreeControlPeer::getClosestNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException)
 904 {
 905     ::vos::OGuard aGuard( GetMutex() );
 906
 907     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 908
 909     Reference< XTreeNode > xNode;
 910
 911     const Point aPos( x, y );
 912     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, TRUE ) );
 913     if( pEntry )
 914         xNode = pEntry->mxNode;
 915
 916     return xNode;
 917 }
 918
 919 // -------------------------------------------------------------------
 920
 921 sal_Bool SAL_CALL TreeControlPeer::isEditing(  ) throw (RuntimeException)
 922 {
 923     ::vos::OGuard aGuard( GetMutex() );
 924
 925     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 926     return rTree.IsEditingActive() ? sal_True : sal_False;
 927 }
 928
 929 // -------------------------------------------------------------------
 930
 931 sal_Bool SAL_CALL TreeControlPeer::stopEditing() throw (RuntimeException)
 932 {
 933     ::vos::OGuard aGuard( GetMutex() );
 934
 935     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 936     if( rTree.IsEditingActive() )
 937     {
 938         rTree.EndEditing(FALSE);
 939         return sal_True;
 940     }
 941     else
 942     {
 943         return sal_False;
 944     }
 945 }
 946
 947 // -------------------------------------------------------------------
 948
 949 void SAL_CALL TreeControlPeer::cancelEditing(  ) throw (RuntimeException)
 950 {
 951     ::vos::OGuard aGuard( GetMutex() );
 952
 953     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 954     rTree.EndEditing(FALSE);
 955 }
 956
 957 // -------------------------------------------------------------------
 958
 959 void SAL_CALL TreeControlPeer::startEditingAtNode( const Reference< XTreeNode >& xNode ) throw (IllegalArgumentException, RuntimeException)
 960 {
 961     ::vos::OGuard aGuard( GetMutex() );
 962
 963     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 964     UnoTreeListEntry* pEntry = getEntry( xNode );
 965     rTree.EditEntry( pEntry );
 966 }
 967
 968 void SAL_CALL TreeControlPeer::addTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException)
 969 {
 970     maTreeEditListeners.addInterface( xListener );
 971 }
 972
 973 void SAL_CALL TreeControlPeer::removeTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException)
 974 {
 975     maTreeEditListeners.removeInterface( xListener );
 976 }
 977
 978 bool TreeControlPeer::onEditingEntry( UnoTreeListEntry* pEntry )
 979 {
 980     if( mpTreeImpl && pEntry && pEntry->mxNode.is() && (maTreeEditListeners.getLength() > 0)  )
 981     {
 982         try
 983         {
 984             maTreeEditListeners.nodeEditing( pEntry->mxNode );
 985         }
 986         catch( VetoException& )
 987         {
 988             return false;
 989         }
 990         catch( Exception& )
 991         {
 992         }
 993     }
 994     return true;
 995 }
 996
 997 bool TreeControlPeer::onEditedEntry( UnoTreeListEntry* pEntry, const XubString& rNewText )
 998 {
 999     if( mpTreeImpl && pEntry && pEntry->mxNode.is() ) try
1000     {
1001         LockGuard aLockGuard( mnEditLock );
1002         const OUString aNewText( rNewText );
1003         if( maTreeEditListeners.getLength() > 0 )
1004         {
1005             maTreeEditListeners.nodeEdited( pEntry->mxNode, aNewText );
1006             return false;
1007         }
1008         else
1009         {
1010             Reference< XMutableTreeNode > xMutableNode( pEntry->mxNode, UNO_QUERY );
1011             if( xMutableNode.is() )
1012                 xMutableNode->setDisplayValue( Any( aNewText ) );
1013             else
1014                 return false;
1015         }
1016
1017     }
1018     catch( Exception& )
1019     {
1020     }
1021
1022     return true;
1023 }
1024
1025 // --------------------------------------------------------------------
1026 // ::com::sun::star::awt::tree::TreeDataModelListener
1027 // --------------------------------------------------------------------
1028
1029 void SAL_CALL TreeControlPeer::treeNodesChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1030 {
1031     ::vos::OGuard aGuard( GetMutex() );
1032
1033     if( mnEditLock != 0 )
1034         return;
1035
1036     updateTree( rEvent, true );
1037 }
1038
1039 void SAL_CALL TreeControlPeer::treeNodesInserted( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1040 {
1041     ::vos::OGuard aGuard( GetMutex() );
1042
1043     if( mnEditLock != 0 )
1044         return;
1045
1046     updateTree( rEvent, true );
1047 }
1048
1049 void SAL_CALL TreeControlPeer::treeNodesRemoved( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1050 {
1051     ::vos::OGuard aGuard( GetMutex() );
1052
1053     if( mnEditLock != 0 )
1054         return;
1055
1056     updateTree( rEvent, true );
1057 }
1058
1059 void SAL_CALL TreeControlPeer::treeStructureChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1060 {
1061     ::vos::OGuard aGuard( GetMutex() );
1062
1063     if( mnEditLock != 0 )
1064         return;
1065
1066     updateTree( rEvent, true );
1067 }
1068
1069 void TreeControlPeer::updateTree( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent, bool bRecursive )
1070 {
1071     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1072
1073     Sequence< Reference< XTreeNode > > Nodes;
1074     Reference< XTreeNode > xNode( rEvent.ParentNode );
1075     if( !xNode.is() && Nodes.getLength() )
1076     {
1077         xNode = Nodes[0];
1078     }
1079
1080     if( xNode.is() )
1081         updateNode( rTree, xNode, bRecursive );
1082 }
1083
1084 void TreeControlPeer::updateNode( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xNode, bool bRecursive )
1085 {
1086     if( xNode.is() )
1087     {
1088         UnoTreeListEntry* pNodeEntry = getEntry( xNode, false );
1089
1090         if( !pNodeEntry )
1091         {
1092             Reference< XTreeNode > xParentNode( xNode->getParent() );
1093             UnoTreeListEntry* pParentEntry = 0;
1094             ULONG nChild = LIST_APPEND;
1095
1096             if( xParentNode.is() )
1097             {
1098                 pParentEntry = getEntry( xParentNode  );
1099                 nChild = xParentNode->getIndex( xNode );
1100             }
1101
1102             pNodeEntry = createEntry( xNode, pParentEntry, nChild );
1103         }
1104
1105         if( bRecursive )
1106             updateChildNodes( rTree, xNode, pNodeEntry );
1107     }
1108 }
1109
1110 void TreeControlPeer::updateChildNodes( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xParentNode, UnoTreeListEntry* pParentEntry )
1111 {
1112     if( xParentNode.is() && pParentEntry )
1113     {
1114         UnoTreeListEntry* pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.FirstChild( pParentEntry ) );
1115
1116         const sal_Int32 nChildCount = xParentNode->getChildCount();
1117         for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ )
1118         {
1119             Reference< XTreeNode > xNode( xParentNode->getChildAt( nChild ) );
1120             if( !pCurrentChild || ( pCurrentChild->mxNode != xNode ) )
1121             {
1122                 UnoTreeListEntry* pNodeEntry = getEntry( xNode, false );
1123                 if( pNodeEntry == 0 )
1124                 {
1125                     // child node is not yet part of the tree, add it
1126                     pCurrentChild = createEntry( xNode, pParentEntry, nChild );
1127                 }
1128                 else if( pNodeEntry != pCurrentChild )
1129                 {
1130                     // node is already part of the tree, but not on the correct position
1131                     rTree.GetModel()->Move( pNodeEntry, pParentEntry, nChild );
1132                     pCurrentChild = pNodeEntry;
1133                     updateEntry( pCurrentChild );
1134                 }
1135             }
1136             else
1137             {
1138                 // child node has entry and entry is equal to current entry,
1139                 // so no structural changes happened
1140                 updateEntry( pCurrentChild );
1141             }
1142
1143             pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) );
1144         }
1145
1146         // check if we have entries without nodes left, we need to remove them
1147         while( pCurrentChild )
1148         {
1149             UnoTreeListEntry* pNextChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) );
1150             rTree.GetModel()->Remove( pCurrentChild );
1151             pCurrentChild = pNextChild;
1152         }
1153     }
1154 }
1155
1156 OUString TreeControlPeer::getEntryString( const Any& rValue )
1157 {
1158     OUString sValue;
1159     if( rValue.hasValue() )
1160     {
1161         switch( rValue.getValueTypeClass() )
1162         {
1163         case TypeClass_SHORT:
1164         case TypeClass_LONG:
1165             {
1166                 sal_Int32 nValue = 0;
1167                 if( rValue >>= nValue )
1168                     sValue = OUString::valueOf( nValue );
1169                 break;
1170             }
1171         case TypeClass_BYTE:
1172         case TypeClass_UNSIGNED_SHORT:
1173         case TypeClass_UNSIGNED_LONG:
1174             {
1175                 sal_uInt32 nValue = 0;
1176                 if( rValue >>= nValue )
1177                     sValue = OUString::valueOf( (sal_Int64)nValue );
1178                 break;
1179             }
1180         case TypeClass_HYPER:
1181             {
1182                 sal_Int64 nValue = 0;
1183                 if( rValue >>= nValue )
1184                     sValue = OUString::valueOf( nValue );
1185                 break;
1186             }
1187         case TypeClass_UNSIGNED_HYPER:
1188             {
1189                 sal_uInt64 nValue = 0;
1190                 if( rValue >>= nValue )
1191                     sValue = OUString::valueOf( (sal_Int64)nValue );
1192                 break;
1193             }
1194         case TypeClass_FLOAT:
1195         case TypeClass_DOUBLE:
1196             {
1197                 double fValue = 0.0;
1198                 if( rValue >>= fValue )
1199                     sValue = OUString::valueOf( fValue );
1200                 break;
1201             }
1202         case TypeClass_STRING:
1203             rValue >>= sValue;
1204             break;
1205     /*
1206         case TypeClass_INTERFACE:
1207             // @todo
1208             break;
1209         case TypeClass_SEQUENCE:
1210             {
1211                 Sequence< Any > aValues;
1212                 if( aValue >>= aValues )
1213                 {
1214                     updateEntry( SvLBoxEntry& rEntry, aValues );
1215                     return;
1216                 }
1217             }
1218             break;
1219     */
1220         default:
1221             break;
1222         }
1223     }
1224     return sValue;
1225 }
1226
1227 // XEventListener
1228 void SAL_CALL TreeControlPeer::disposing( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::uno::RuntimeException)
1229 {
1230     // model is disposed, so we clear our tree
1231     ::vos::OGuard aGuard( GetMutex() );
1232     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1233     rTree.Clear();
1234     mxDataModel.clear();
1235 }
1236
1237 void TreeControlPeer::onChangeDataModel( UnoTreeListBoxImpl& rTree, const Reference< XTreeDataModel >& xDataModel )
1238 {
1239     if( xDataModel.is() && (mxDataModel == xDataModel) )
1240         return; // do nothing
1241
1242     Reference< XTreeDataModelListener > xListener( this );
1243
1244     if( mxDataModel.is() )
1245         mxDataModel->removeTreeDataModelListener( xListener );
1246
1247     if( !xDataModel.is() )
1248     {
1249         static const OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.tree.DefaultTreeDataModel" ) );
1250         Reference< XMultiServiceFactory > xORB( ::comphelper::getProcessServiceFactory() );
1251         if( xORB.is() )
1252         {
1253             mxDataModel.query( xORB->createInstance( aSN ) );
1254         }
1255     }
1256
1257     mxDataModel = xDataModel;
1258
1259     fillTree( rTree, mxDataModel );
1260
1261     if( mxDataModel.is() )
1262         mxDataModel->addTreeDataModelListener( xListener );
1263 }
1264
1265 // --------------------------------------------------------------------
1266 // ::com::sun::star::awt::XLayoutConstrains
1267 // --------------------------------------------------------------------
1268
1269 ::com::sun::star::awt::Size TreeControlPeer::getMinimumSize() throw(RuntimeException)
1270 {
1271     ::vos::OGuard aGuard( GetMutex() );
1272
1273     ::com::sun::star::awt::Size aSz;
1274 /* todo
1275     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
1276     if ( pEdit )
1277         aSz = AWTSize(pEdit->CalcMinimumSize());
1278 */
1279     return aSz;
1280 }
1281
1282 ::com::sun::star::awt::Size TreeControlPeer::getPreferredSize() throw(RuntimeException)
1283 {
1284     return getMinimumSize();
1285 }
1286
1287 ::com::sun::star::awt::Size TreeControlPeer::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(RuntimeException)
1288 {
1289     ::vos::OGuard aGuard( GetMutex() );
1290
1291     ::com::sun::star::awt::Size aSz = rNewSize;
1292 /* todo
1293     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
1294     if ( pEdit )
1295         aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize )));
1296 */
1297     return aSz;
1298 }
1299
1300 // --------------------------------------------------------------------
1301 // ::com::sun::star::awt::XVclWindowPeer
1302 // --------------------------------------------------------------------
1303
1304 void TreeControlPeer::setProperty( const ::rtl::OUString& PropertyName, const Any& aValue) throw(RuntimeException)
1305 {
1306     ::vos::OGuard aGuard( GetMutex() );
1307
1308     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1309
1310     switch( GetPropertyId( PropertyName ) )
1311     {
1312         case BASEPROPERTY_TREE_SELECTIONTYPE:
1313         {
1314             SelectionType eSelectionType;
1315             if( aValue >>= eSelectionType )
1316             {
1317                 SelectionMode eSelMode;
1318                 switch( eSelectionType )
1319                 {
1320                 case SelectionType_SINGLE:      eSelMode = SINGLE_SELECTION; break;
1321                 case SelectionType_RANGE:       eSelMode = RANGE_SELECTION; break;
1322                 case SelectionType_MULTI:       eSelMode = MULTIPLE_SELECTION; break;
1323     //                  case SelectionType_NONE:
1324                 default:                                        eSelMode = NO_SELECTION; break;
1325                 }
1326                 if( rTree.GetSelectionMode() != eSelMode )
1327                     rTree.SetSelectionMode( eSelMode );
1328             }
1329             break;
1330         }
1331
1332         case BASEPROPERTY_TREE_DATAMODEL:
1333             onChangeDataModel( rTree, Reference< XTreeDataModel >( aValue, UNO_QUERY ) );
1334             break;
1335         case BASEPROPERTY_TREE_ROWHEIGHT:
1336         {
1337             sal_Int32 nHeight = 0;
1338             if( aValue >>= nHeight )
1339                 rTree.SetEntryHeight( (short)nHeight );
1340             break;
1341         }
1342         case BASEPROPERTY_TREE_EDITABLE:
1343         {
1344             sal_Bool bEnabled = false;
1345             if( aValue >>= bEnabled )
1346                 rTree.EnableInplaceEditing( bEnabled ? TRUE : FALSE );
1347             break;
1348         }
1349         case BASEPROPERTY_TREE_INVOKESSTOPNODEEDITING:
1350             break; // @todo
1351         case BASEPROPERTY_TREE_ROOTDISPLAYED:
1352         {
1353             sal_Bool bDisplayed = false;
1354             if( (aValue >>= bDisplayed) && ( bDisplayed != mbIsRootDisplayed) )
1355             {
1356                 onChangeRootDisplayed(bDisplayed);
1357             }
1358             break;
1359         }
1360         case BASEPROPERTY_TREE_SHOWSHANDLES:
1361         {
1362             sal_Bool bEnabled = false;
1363             if( aValue >>= bEnabled )
1364             {
1365                 WinBits nBits = rTree.GetWindowBits() & (~WB_HASLINES);
1366                 if( bEnabled )
1367                     nBits |= WB_HASLINES;
1368                 if( nBits != rTree.GetWindowBits() )
1369                     rTree.SetWindowBits( nBits );
1370             }
1371             break;
1372         }
1373         case BASEPROPERTY_TREE_SHOWSROOTHANDLES:
1374         {
1375             sal_Bool bEnabled = false;
1376             if( aValue >>= bEnabled )
1377             {
1378                 WinBits nBits = rTree.GetWindowBits() & (~WB_HASLINESATROOT);
1379                 if( bEnabled )
1380                     nBits |= WB_HASLINESATROOT;
1381                 if( nBits != rTree.GetWindowBits() )
1382                     rTree.SetWindowBits( nBits );
1383             }
1384             break;
1385         }
1386         default:
1387         VCLXWindow::setProperty( PropertyName, aValue );
1388         break;
1389     }
1390 }
1391
1392 Any TreeControlPeer::getProperty( const ::rtl::OUString& PropertyName ) throw(RuntimeException)
1393 {
1394     ::vos::OGuard aGuard( GetMutex() );
1395
1396     const sal_uInt16 nPropId = GetPropertyId( PropertyName );
1397     if( (nPropId >= BASEPROPERTY_TREE_START) && (nPropId <= BASEPROPERTY_TREE_END) )
1398     {
1399         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1400         switch(nPropId)
1401         {
1402         case BASEPROPERTY_TREE_SELECTIONTYPE:
1403         {
1404             SelectionType eSelectionType;
1405
1406             SelectionMode eSelMode = rTree.GetSelectionMode();
1407             switch( eSelMode )
1408             {
1409             case SINGLE_SELECTION:      eSelectionType = SelectionType_SINGLE; break;
1410             case RANGE_SELECTION:       eSelectionType = SelectionType_RANGE; break;
1411             case MULTIPLE_SELECTION:eSelectionType = SelectionType_MULTI; break;
1412 //                      case NO_SELECTION:
1413             default:                            eSelectionType = SelectionType_NONE; break;
1414             }
1415             return Any( eSelectionType );
1416         }
1417         case BASEPROPERTY_TREE_ROWHEIGHT:
1418             return Any( (sal_Int32)rTree.GetEntryHeight() );
1419         case BASEPROPERTY_TREE_DATAMODEL:
1420             return Any( mxDataModel );
1421         case BASEPROPERTY_TREE_EDITABLE:
1422             return Any( rTree.IsInplaceEditingEnabled() ? sal_True : sal_False );
1423         case BASEPROPERTY_TREE_INVOKESSTOPNODEEDITING:
1424             return Any( sal_True ); // @todo
1425         case BASEPROPERTY_TREE_ROOTDISPLAYED:
1426             return Any( mbIsRootDisplayed );
1427         case BASEPROPERTY_TREE_SHOWSHANDLES:
1428             return Any( (rTree.GetWindowBits() & WB_HASLINES) != 0 ? sal_True : sal_False );
1429         case BASEPROPERTY_TREE_SHOWSROOTHANDLES:
1430             return Any( (rTree.GetWindowBits() & WB_HASLINESATROOT) != 0 ? sal_True : sal_False );
1431         }
1432     }
1433     return VCLXWindow::getProperty( PropertyName );
1434 }
1435
1436 void TreeControlPeer::onChangeRootDisplayed( sal_Bool bIsRootDisplayed )
1437 {
1438     if( mbIsRootDisplayed == bIsRootDisplayed )
1439         return;
1440
1441     mbIsRootDisplayed = bIsRootDisplayed;
1442
1443     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1444
1445     if( rTree.GetEntryCount() == 0 )
1446         return;
1447
1448     // todo
1449     fillTree( rTree, mxDataModel );
1450     if( mbIsRootDisplayed )
1451     {
1452     }
1453     else
1454     {
1455     }
1456 }
1457
1458 bool TreeControlPeer::loadImage( const ::rtl::OUString& rURL, Image& rImage )
1459 {
1460     if( !mxGraphicProvider.is() )
1461     {
1462         static const OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicProvider" ) );
1463         Reference< XMultiServiceFactory > xORB( ::comphelper::getProcessServiceFactory() );
1464         if( xORB.is() )
1465         {
1466             Reference< XInterface > x( xORB->createInstance( aSN ) );
1467             mxGraphicProvider.query( x );
1468             mxGraphicProvider = Reference< XGraphicProvider >( x, UNO_QUERY );
1469         }
1470     }
1471
1472     if( mxGraphicProvider.is() ) try
1473     {
1474         ::com::sun::star::beans::PropertyValues aProps( 1 );
1475         aProps[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) );
1476         aProps[0].Value <<= rURL;
1477
1478         Reference< XGraphic > xGraphic( mxGraphicProvider->queryGraphic( aProps ) );
1479
1480         Graphic aGraphic( xGraphic );
1481         rImage = aGraphic.GetBitmapEx();
1482         return true;
1483     }
1484     catch( Exception& )
1485     {
1486     }
1487
1488     return false;
1489 }
1490
1491 // ====================================================================
1492 // class UnoTreeListBoxImpl
1493 // ====================================================================
1494
1495 UnoTreeListBoxImpl::UnoTreeListBoxImpl( TreeControlPeer* pPeer, Window* pParent, WinBits nWinStyle )
1496 : SvTreeListBox( pParent, nWinStyle )
1497 , mxPeer( pPeer )
1498 {
1499     SetWindowBits( WB_BORDER | WB_HASLINES |WB_HASBUTTONS | WB_HASLINESATROOT | WB_HASBUTTONSATROOT | WB_HSCROLL );
1500     SetNodeDefaultImages();
1501     SetSelectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) );
1502     SetDeselectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) );
1503
1504     SetExpandingHdl( LINK(this, UnoTreeListBoxImpl, OnExpandingHdl) );
1505     SetExpandedHdl( LINK(this, UnoTreeListBoxImpl, OnExpandedHdl) );
1506
1507 }
1508
1509 // --------------------------------------------------------------------
1510
1511 UnoTreeListBoxImpl::~UnoTreeListBoxImpl()
1512 {
1513     if( mxPeer.is() )
1514         mxPeer->disposeControl();
1515 }
1516
1517 // --------------------------------------------------------------------
1518
1519 IMPL_LINK( UnoTreeListBoxImpl, OnSelectionChangeHdl, UnoTreeListBoxImpl*, EMPTYARG )
1520 {
1521     if( mxPeer.is() )
1522         mxPeer->onSelectionChanged();
1523     return 0;
1524 }
1525
1526 // --------------------------------------------------------------------
1527
1528 IMPL_LINK(UnoTreeListBoxImpl, OnExpandingHdl, UnoTreeListBoxImpl*, EMPTYARG )
1529 {
1530     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() );
1531
1532     if( pEntry && mxPeer.is() )
1533     {
1534         return mxPeer->onExpanding( pEntry->mxNode, !IsExpanded( pEntry ) ) ? 1 : 0;
1535     }
1536     return 0;
1537 }
1538
1539 // --------------------------------------------------------------------
1540
1541 IMPL_LINK(UnoTreeListBoxImpl, OnExpandedHdl, UnoTreeListBoxImpl*, EMPTYARG )
1542 {
1543     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() );
1544     if( pEntry && mxPeer.is() )
1545     {
1546         mxPeer->onExpanded( pEntry->mxNode, IsExpanded( pEntry ) );
1547     }
1548     return 0;
1549 }
1550
1551 // --------------------------------------------------------------------
1552
1553 sal_uInt32 UnoTreeListBoxImpl::insert( SvLBoxEntry* pEntry,SvLBoxEntry* pParent,ULONG nPos )
1554 {
1555     if( pParent )
1556         return SvTreeListBox::Insert( pEntry, pParent, nPos );
1557     else
1558         return SvTreeListBox::Insert( pEntry, nPos );
1559 }
1560
1561 // --------------------------------------------------------------------
1562
1563 void UnoTreeListBoxImpl::RequestingChilds( SvLBoxEntry* pParent )
1564 {
1565     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( pParent );
1566     if( pEntry && pEntry->mxNode.is() && mxPeer.is() )
1567         mxPeer->onRequestChildNodes( pEntry->mxNode );
1568 }
1569
1570 // --------------------------------------------------------------------
1571
1572 BOOL UnoTreeListBoxImpl::EditingEntry( SvLBoxEntry* pEntry, Selection& )
1573 {
1574     return mxPeer.is() ? mxPeer->onEditingEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ) ) : false;
1575 }
1576
1577 // --------------------------------------------------------------------
1578
1579 BOOL UnoTreeListBoxImpl::EditedEntry( SvLBoxEntry* pEntry, const XubString& rNewText )
1580 {
1581     return mxPeer.is() ? mxPeer->onEditedEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ), rNewText ) : false;
1582 }
1583
1584 // ====================================================================
1585 // class UnoTreeListItem
1586 // ====================================================================
1587
1588 UnoTreeListItem::UnoTreeListItem( SvLBoxEntry* pEntry )
1589 : SvLBoxItem( pEntry, 0 )
1590 {
1591 }
1592
1593 // --------------------------------------------------------------------
1594
1595 UnoTreeListItem::UnoTreeListItem()
1596 : SvLBoxItem()
1597 {
1598 }
1599
1600 // --------------------------------------------------------------------
1601
1602 UnoTreeListItem::~UnoTreeListItem()
1603 {
1604 }
1605
1606 // --------------------------------------------------------------------
1607
1608 USHORT UnoTreeListItem::IsA()
1609 {
1610     return 0;
1611 }
1612
1613 // --------------------------------------------------------------------
1614
1615 void UnoTreeListItem::Paint( const Point& rPos, SvLBox& rDev, USHORT /* nFlags */, SvLBoxEntry* _pEntry)
1616 {
1617     Point aPos( rPos );
1618     if( _pEntry )
1619     {
1620         Size aSize( GetSize(&rDev,_pEntry) );
1621         if( !!maImage )
1622         {
1623             rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE );
1624             int nWidth = maImage.GetSizePixel().Width() + 6;
1625             aPos.X() += nWidth;
1626             aSize.Width() -= nWidth;
1627         }
1628         rDev.DrawText( Rectangle(aPos,aSize),maText, rDev.IsEnabled() ? 0 : TEXT_DRAW_DISABLE );
1629     }
1630     else
1631     {
1632         if( !!maImage )
1633         {
1634             rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE);
1635             aPos.X() += maImage.GetSizePixel().Width() + 6;
1636         }
1637         rDev.DrawText( aPos, maText);
1638     }
1639 }
1640
1641 // --------------------------------------------------------------------
1642
1643 SvLBoxItem* UnoTreeListItem::Create() const
1644 {
1645     return new UnoTreeListItem;
1646 }
1647
1648 // --------------------------------------------------------------------
1649
1650 void UnoTreeListItem::Clone( SvLBoxItem* pSource )
1651 {
1652     UnoTreeListItem* pSourceItem = dynamic_cast< UnoTreeListItem* >( pSource );
1653     if( pSourceItem )
1654     {
1655         maText = pSourceItem->maText;
1656         maImage = pSourceItem->maImage;
1657     }
1658 }
1659
1660 // --------------------------------------------------------------------
1661
1662 OUString UnoTreeListItem::GetText() const
1663 {
1664     return maText;
1665 }
1666
1667 // --------------------------------------------------------------------
1668
1669 void UnoTreeListItem::SetText( const OUString& rText )
1670 {
1671     maText = rText;
1672 }
1673
1674 // --------------------------------------------------------------------
1675
1676 void UnoTreeListItem::SetImage( const Image& rImage )
1677 {
1678     maImage = rImage;
1679 }
1680
1681 // --------------------------------------------------------------------
1682
1683 OUString UnoTreeListItem::GetGraphicURL() const
1684 {
1685     return maGraphicURL;
1686 }
1687
1688 // --------------------------------------------------------------------
1689
1690 void UnoTreeListItem::SetGraphicURL( const OUString& rGraphicURL )
1691 {
1692     maGraphicURL = rGraphicURL;
1693 }
1694
1695 // --------------------------------------------------------------------
1696
1697 void UnoTreeListItem::InitViewData( SvLBox* pView,SvLBoxEntry* pEntry, SvViewDataItem* pViewData)
1698 {
1699     if( !pViewData )
1700         pViewData = pView->GetViewDataItem( pEntry, this );
1701
1702     pViewData->aSize = maImage.GetSizePixel();
1703
1704     const Size aTextSize(pView->GetTextWidth( maText ), pView->GetTextHeight());
1705     if( pViewData->aSize.Width() )
1706     {
1707         pViewData->aSize.Width() += 6 + aTextSize.Width();
1708         if( pViewData->aSize.Height() < aTextSize.Height() )
1709             pViewData->aSize.Height() = aTextSize.Height();
1710     }
1711     else
1712     {
1713         pViewData->aSize = aTextSize;
1714     }
1715 }
1716
1717 // --------------------------------------------------------------------
1718
1719 UnoTreeListEntry::UnoTreeListEntry( const Reference< XTreeNode >& xNode, TreeControlPeer* pPeer )
1720 : SvLBoxEntry()
1721 , mxNode( xNode )
1722 , mpPeer( pPeer )
1723 {
1724     if( mpPeer )
1725         mpPeer->addEntry( this );
1726 }
1727
1728 // --------------------------------------------------------------------
1729
1730 UnoTreeListEntry::~UnoTreeListEntry()
1731 {
1732     if( mpPeer )
1733         mpPeer->removeEntry( this );
1734 }