svtools/source/uno/treecontrolpeer.cxx

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