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     Sequence< XTreeNode > aTempSeq;
 465
 466     const Reference< XTreeNode > *pNodes = 0;
 467     sal_Int32 nCount = 0;
 468
 469     if( rSelection.hasValue() )
 470     {
 471         switch( rSelection.getValueTypeClass() )
 472         {
 473         case TypeClass_INTERFACE:
 474             {
 475                 rSelection >>= xTempNode;
 476                 if( xTempNode.is() )
 477                 {
 478                     nCount = 1;
 479                     pNodes = &xTempNode;
 480                 }
 481                 break;
 482             }
 483         case TypeClass_SEQUENCE:
 484             {
 485                 if( rSelection.getValueType() == ::getCppuType( (const Sequence< Reference< XTreeNode > > *) 0 ) )
 486                 {
 487                     const Sequence< Reference< XTreeNode > >& rSeq( *(const Sequence< Reference< XTreeNode > > *)rSelection.getValue() );
 488                     nCount = rSeq.getLength();
 489                     if( nCount )
 490                         pNodes = rSeq.getConstArray();
 491                 }
 492                 break;
 493             }
 494         default:
 495             break;
 496         }
 497
 498         if( nCount == 0 )
 499             throw IllegalArgumentException();
 500     }
 501
 502     if( bSetSelection )
 503         rTree.SelectAll( sal_False );
 504
 505     if( pNodes && nCount )
 506     {
 507         while( nCount-- )
 508         {
 509             UnoTreeListEntry* pEntry = getEntry( *pNodes++ );
 510             rTree.Select( pEntry, bSelect ? sal_True : sal_False );
 511         }
 512     }
 513 }
 514
 515 // -------------------------------------------------------------------
 516 // ::com::sun::star::view::XSelectionSupplier
 517 // -------------------------------------------------------------------
 518
 519 sal_Bool SAL_CALL TreeControlPeer::select( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 520 {
 521     SolarMutexGuard aGuard;
 522     ChangeNodesSelection( rSelection, true, true );
 523     return sal_True;
 524 }
 525
 526 // -------------------------------------------------------------------
 527
 528 Any SAL_CALL TreeControlPeer::getSelection() throw (RuntimeException)
 529 {
 530     SolarMutexGuard aGuard;
 531
 532     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 533
 534     Any aRet;
 535
 536     sal_uLong nSelectionCount = rTree.GetSelectionCount();
 537     if( nSelectionCount == 1 )
 538     {
 539         UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 540         if( pEntry && pEntry->mxNode.is() )
 541             aRet <<= pEntry->mxNode;
 542     }
 543     else if( nSelectionCount > 1 )
 544     {
 545         Sequence< Reference< XTreeNode > > aSelection( nSelectionCount );
 546         Reference< XTreeNode >* pNodes = aSelection.getArray();
 547         UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 548         while( pEntry && nSelectionCount )
 549         {
 550             *pNodes++ = pEntry->mxNode;
 551             pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 552             --nSelectionCount;
 553         }
 554
 555         OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 556         aRet <<= aSelection;
 557     }
 558
 559     return aRet;
 560 }
 561
 562 // -------------------------------------------------------------------
 563
 564 void SAL_CALL TreeControlPeer::addSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException)
 565 {
 566     maSelectionListeners.addInterface( xListener );
 567 }
 568
 569 // -------------------------------------------------------------------
 570
 571 void SAL_CALL TreeControlPeer::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException)
 572 {
 573     maSelectionListeners.addInterface( xListener );
 574 }
 575
 576 // -------------------------------------------------------------------
 577 // ::com::sun::star::view::XMultiSelectionSupplier
 578 // -------------------------------------------------------------------
 579
 580 sal_Bool SAL_CALL TreeControlPeer::addSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 581 {
 582     ChangeNodesSelection( rSelection, true, false );
 583     return sal_True;
 584 }
 585
 586 // -------------------------------------------------------------------
 587
 588 void SAL_CALL TreeControlPeer::removeSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException)
 589 {
 590     ChangeNodesSelection( rSelection, false, false );
 591 }
 592
 593 // -------------------------------------------------------------------
 594
 595 void SAL_CALL TreeControlPeer::clearSelection() throw (RuntimeException)
 596 {
 597     SolarMutexGuard aGuard;
 598     getTreeListBoxOrThrow().SelectAll( sal_False );
 599 }
 600
 601 // -------------------------------------------------------------------
 602
 603 sal_Int32 SAL_CALL TreeControlPeer::getSelectionCount() throw (RuntimeException)
 604 {
 605     SolarMutexGuard aGuard;
 606     return getTreeListBoxOrThrow().GetSelectionCount();
 607 }
 608
 609 // -------------------------------------------------------------------
 610
 611 class TreeSelectionEnumeration : public ::cppu::WeakImplHelper1< XEnumeration >
 612 {
 613 public:
 614     TreeSelectionEnumeration( std::list< Any >& rSelection );
 615     virtual ::sal_Bool SAL_CALL hasMoreElements() throw (RuntimeException);
 616     virtual Any SAL_CALL nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException);
 617
 618     std::list< Any > maSelection;
 619     std::list< Any >::iterator maIter;
 620 };
 621
 622 // -------------------------------------------------------------------
 623
 624 TreeSelectionEnumeration::TreeSelectionEnumeration( std::list< Any >& rSelection )
 625 {
 626     maSelection.swap( rSelection );
 627     maIter = maSelection.begin();
 628 }
 629
 630 // -------------------------------------------------------------------
 631
 632 ::sal_Bool SAL_CALL TreeSelectionEnumeration::hasMoreElements() throw (RuntimeException)
 633 {
 634     return maIter != maSelection.end();
 635 }
 636
 637 // -------------------------------------------------------------------
 638
 639 Any SAL_CALL TreeSelectionEnumeration::nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException)
 640 {
 641     if( maIter == maSelection.end() )
 642         throw NoSuchElementException();
 643
 644     return (*maIter++);
 645 }
 646
 647 // -------------------------------------------------------------------
 648
 649 Reference< XEnumeration > SAL_CALL TreeControlPeer::createSelectionEnumeration() throw (RuntimeException)
 650 {
 651     SolarMutexGuard aGuard;
 652
 653     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 654
 655     sal_uInt32 nSelectionCount = rTree.GetSelectionCount();
 656     std::list< Any > aSelection( nSelectionCount );
 657
 658     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 659     while( pEntry && nSelectionCount )
 660     {
 661         aSelection.push_back( Any( pEntry->mxNode ) );
 662         pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 663         --nSelectionCount;
 664     }
 665
 666     OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 667
 668     return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) );
 669 }
 670
 671 // -------------------------------------------------------------------
 672
 673 Reference< XEnumeration > SAL_CALL TreeControlPeer::createReverseSelectionEnumeration() throw (RuntimeException)
 674 {
 675     SolarMutexGuard aGuard;
 676
 677     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 678
 679     sal_uInt32 nSelectionCount = rTree.GetSelectionCount();
 680     std::list< Any > aSelection;
 681
 682     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() );
 683     while( pEntry && nSelectionCount )
 684     {
 685         aSelection.push_front( Any( pEntry->mxNode ) );
 686         pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) );
 687         --nSelectionCount;
 688     }
 689
 690     OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) );
 691
 692     return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) );
 693 }
 694
 695 // --------------------------------------------------------------------
 696 // ::com::sun::star::awt::XTreeControl
 697 // --------------------------------------------------------------------
 698
 699 OUString SAL_CALL TreeControlPeer::getDefaultExpandedGraphicURL() throw (::com::sun::star::uno::RuntimeException)
 700 {
 701     SolarMutexGuard aGuard;
 702     return msDefaultExpandedGraphicURL;
 703 }
 704
 705 // --------------------------------------------------------------------
 706
 707 void SAL_CALL TreeControlPeer::setDefaultExpandedGraphicURL( const OUString& sDefaultExpandedGraphicURL ) throw (::com::sun::star::uno::RuntimeException)
 708 {
 709     SolarMutexGuard aGuard;
 710     if( msDefaultExpandedGraphicURL != sDefaultExpandedGraphicURL )
 711     {
 712         if( !sDefaultExpandedGraphicURL.isEmpty() )
 713             loadImage( sDefaultExpandedGraphicURL, maDefaultExpandedImage );
 714         else
 715             maDefaultExpandedImage = Image();
 716
 717         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 718
 719         SvTreeListEntry* pEntry = rTree.First();
 720         while( pEntry )
 721         {
 722             ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) );
 723             if( pContextGraphicItem )
 724             {
 725                 if( pContextGraphicItem->msExpandedGraphicURL.isEmpty() )
 726                     rTree.SetExpandedEntryBmp( pEntry, maDefaultExpandedImage );
 727             }
 728             pEntry = rTree.Next( pEntry );
 729         }
 730
 731         msDefaultExpandedGraphicURL = sDefaultExpandedGraphicURL;
 732     }
 733 }
 734
 735 // --------------------------------------------------------------------
 736
 737 OUString SAL_CALL TreeControlPeer::getDefaultCollapsedGraphicURL() throw (::com::sun::star::uno::RuntimeException)
 738 {
 739     SolarMutexGuard aGuard;
 740     return msDefaultCollapsedGraphicURL;
 741 }
 742
 743 // --------------------------------------------------------------------
 744
 745 void SAL_CALL TreeControlPeer::setDefaultCollapsedGraphicURL( const OUString& sDefaultCollapsedGraphicURL ) throw (::com::sun::star::uno::RuntimeException)
 746 {
 747     SolarMutexGuard aGuard;
 748     if( msDefaultCollapsedGraphicURL != sDefaultCollapsedGraphicURL )
 749     {
 750         if( !sDefaultCollapsedGraphicURL.isEmpty() )
 751             loadImage( sDefaultCollapsedGraphicURL, maDefaultCollapsedImage );
 752         else
 753             maDefaultCollapsedImage = Image();
 754
 755         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 756
 757         SvTreeListEntry* pEntry = rTree.First();
 758         while( pEntry )
 759         {
 760             ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) );
 761             if( pContextGraphicItem )
 762             {
 763                 if( pContextGraphicItem->msCollapsedGraphicURL.isEmpty() )
 764                     rTree.SetCollapsedEntryBmp( pEntry, maDefaultCollapsedImage );
 765             }
 766             pEntry = rTree.Next( pEntry );
 767         }
 768
 769         msDefaultCollapsedGraphicURL = sDefaultCollapsedGraphicURL;
 770     }
 771 }
 772
 773 // --------------------------------------------------------------------
 774
 775 sal_Bool SAL_CALL TreeControlPeer::isNodeExpanded( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 776 {
 777     SolarMutexGuard aGuard;
 778
 779     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 780     UnoTreeListEntry* pEntry = getEntry( xNode );
 781     return ( pEntry && rTree.IsExpanded( pEntry ) ) ? sal_True : sal_False;
 782 }
 783
 784 // -------------------------------------------------------------------
 785
 786 sal_Bool SAL_CALL TreeControlPeer::isNodeCollapsed( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 787 {
 788     SolarMutexGuard aGuard;
 789     return !isNodeExpanded( xNode );
 790 }
 791
 792 // -------------------------------------------------------------------
 793
 794 void SAL_CALL TreeControlPeer::makeNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 795 {
 796     SolarMutexGuard aGuard;
 797
 798     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 799     UnoTreeListEntry* pEntry = getEntry( xNode );
 800     if( pEntry )
 801         rTree.MakeVisible( pEntry );
 802 }
 803
 804 // -------------------------------------------------------------------
 805
 806 sal_Bool SAL_CALL TreeControlPeer::isNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException)
 807 {
 808     SolarMutexGuard aGuard;
 809
 810     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 811     UnoTreeListEntry* pEntry = getEntry( xNode );
 812     return ( pEntry && rTree.IsEntryVisible( pEntry ) ) ? sal_True : sal_False;
 813 }
 814
 815 // -------------------------------------------------------------------
 816
 817 void SAL_CALL TreeControlPeer::expandNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 818 {
 819     SolarMutexGuard aGuard;
 820
 821     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 822     UnoTreeListEntry* pEntry = getEntry( xNode );
 823     if( pEntry )
 824         rTree.Expand( pEntry );
 825 }
 826
 827 // -------------------------------------------------------------------
 828
 829 void SAL_CALL TreeControlPeer::collapseNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException)
 830 {
 831     SolarMutexGuard aGuard;
 832
 833     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 834     UnoTreeListEntry* pEntry = getEntry( xNode );
 835     if( pEntry )
 836         rTree.Collapse( pEntry );
 837 }
 838
 839 // -------------------------------------------------------------------
 840
 841 void SAL_CALL TreeControlPeer::addTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException)
 842 {
 843     maTreeExpansionListeners.addInterface( xListener );
 844 }
 845
 846 // -------------------------------------------------------------------
 847
 848 void SAL_CALL TreeControlPeer::removeTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException)
 849 {
 850     maTreeExpansionListeners.removeInterface( xListener );
 851 }
 852
 853 // -------------------------------------------------------------------
 854
 855 Reference< XTreeNode > SAL_CALL TreeControlPeer::getNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException)
 856 {
 857     SolarMutexGuard aGuard;
 858
 859     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 860
 861     Reference< XTreeNode > xNode;
 862
 863     const Point aPos( x, y );
 864     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, sal_True ) );
 865     if( pEntry )
 866         xNode = pEntry->mxNode;
 867
 868     return xNode;
 869 }
 870
 871 // -------------------------------------------------------------------
 872
 873 Reference< XTreeNode > SAL_CALL TreeControlPeer::getClosestNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException)
 874 {
 875     SolarMutexGuard aGuard;
 876
 877     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 878
 879     Reference< XTreeNode > xNode;
 880
 881     const Point aPos( x, y );
 882     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, sal_True ) );
 883     if( pEntry )
 884         xNode = pEntry->mxNode;
 885
 886     return xNode;
 887 }
 888
 889 // -------------------------------------------------------------------
 890
 891 awt::Rectangle SAL_CALL TreeControlPeer::getNodeRect( const Reference< XTreeNode >& i_Node ) throw (IllegalArgumentException, RuntimeException)
 892 {
 893     SolarMutexGuard aGuard;
 894
 895     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 896     UnoTreeListEntry* pEntry = getEntry( i_Node, true );
 897
 898     ::Rectangle aEntryRect( rTree.GetFocusRect( pEntry, rTree.GetEntryPosition( pEntry ).Y() ) );
 899     return VCLUnoHelper::ConvertToAWTRect( aEntryRect );
 900 }
 901
 902 // -------------------------------------------------------------------
 903
 904 sal_Bool SAL_CALL TreeControlPeer::isEditing(  ) throw (RuntimeException)
 905 {
 906     SolarMutexGuard aGuard;
 907
 908     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 909     return rTree.IsEditingActive() ? sal_True : sal_False;
 910 }
 911
 912 // -------------------------------------------------------------------
 913
 914 sal_Bool SAL_CALL TreeControlPeer::stopEditing() throw (RuntimeException)
 915 {
 916     SolarMutexGuard aGuard;
 917
 918     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 919     if( rTree.IsEditingActive() )
 920     {
 921         rTree.EndEditing(sal_False);
 922         return sal_True;
 923     }
 924     else
 925     {
 926         return sal_False;
 927     }
 928 }
 929
 930 // -------------------------------------------------------------------
 931
 932 void SAL_CALL TreeControlPeer::cancelEditing(  ) throw (RuntimeException)
 933 {
 934     SolarMutexGuard aGuard;
 935
 936     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 937     rTree.EndEditing(sal_False);
 938 }
 939
 940 // -------------------------------------------------------------------
 941
 942 void SAL_CALL TreeControlPeer::startEditingAtNode( const Reference< XTreeNode >& xNode ) throw (IllegalArgumentException, RuntimeException)
 943 {
 944     SolarMutexGuard aGuard;
 945
 946     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
 947     UnoTreeListEntry* pEntry = getEntry( xNode );
 948     rTree.EditEntry( pEntry );
 949 }
 950
 951 void SAL_CALL TreeControlPeer::addTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException)
 952 {
 953     maTreeEditListeners.addInterface( xListener );
 954 }
 955
 956 void SAL_CALL TreeControlPeer::removeTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException)
 957 {
 958     maTreeEditListeners.removeInterface( xListener );
 959 }
 960
 961 bool TreeControlPeer::onEditingEntry( UnoTreeListEntry* pEntry )
 962 {
 963     if( mpTreeImpl && pEntry && pEntry->mxNode.is() && (maTreeEditListeners.getLength() > 0)  )
 964     {
 965         try
 966         {
 967             maTreeEditListeners.nodeEditing( pEntry->mxNode );
 968         }
 969         catch( VetoException& )
 970         {
 971             return false;
 972         }
 973         catch( Exception& )
 974         {
 975         }
 976     }
 977     return true;
 978 }
 979
 980 bool TreeControlPeer::onEditedEntry( UnoTreeListEntry* pEntry, const OUString& rNewText )
 981 {
 982     if( mpTreeImpl && pEntry && pEntry->mxNode.is() ) try
 983     {
 984         LockGuard aLockGuard( mnEditLock );
 985         if( maTreeEditListeners.getLength() > 0 )
 986         {
 987             maTreeEditListeners.nodeEdited( pEntry->mxNode, rNewText );
 988             return false;
 989         }
 990         else
 991         {
 992             Reference< XMutableTreeNode > xMutableNode( pEntry->mxNode, UNO_QUERY );
 993             if( xMutableNode.is() )
 994                 xMutableNode->setDisplayValue( Any( rNewText ) );
 995             else
 996                 return false;
 997         }
 998
 999     }
1000     catch( Exception& )
1001     {
1002     }
1003
1004     return true;
1005 }
1006
1007 // --------------------------------------------------------------------
1008 // ::com::sun::star::awt::tree::TreeDataModelListener
1009 // --------------------------------------------------------------------
1010
1011 void SAL_CALL TreeControlPeer::treeNodesChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1012 {
1013     SolarMutexGuard aGuard;
1014
1015     if( mnEditLock != 0 )
1016         return;
1017
1018     updateTree( rEvent, true );
1019 }
1020
1021 void SAL_CALL TreeControlPeer::treeNodesInserted( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1022 {
1023     SolarMutexGuard aGuard;
1024
1025     if( mnEditLock != 0 )
1026         return;
1027
1028     updateTree( rEvent, true );
1029 }
1030
1031 void SAL_CALL TreeControlPeer::treeNodesRemoved( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1032 {
1033     SolarMutexGuard aGuard;
1034
1035     if( mnEditLock != 0 )
1036         return;
1037
1038     updateTree( rEvent, true );
1039 }
1040
1041 void SAL_CALL TreeControlPeer::treeStructureChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException)
1042 {
1043     SolarMutexGuard aGuard;
1044
1045     if( mnEditLock != 0 )
1046         return;
1047
1048     updateTree( rEvent, true );
1049 }
1050
1051 void TreeControlPeer::updateTree( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent, bool bRecursive )
1052 {
1053     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1054
1055     Sequence< Reference< XTreeNode > > Nodes;
1056     Reference< XTreeNode > xNode( rEvent.ParentNode );
1057     if( !xNode.is() && Nodes.getLength() )
1058     {
1059         xNode = Nodes[0];
1060     }
1061
1062     if( xNode.is() )
1063         updateNode( rTree, xNode, bRecursive );
1064 }
1065
1066 void TreeControlPeer::updateNode( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xNode, bool bRecursive )
1067 {
1068     if( xNode.is() )
1069     {
1070         UnoTreeListEntry* pNodeEntry = getEntry( xNode, false );
1071
1072         if( !pNodeEntry )
1073         {
1074             Reference< XTreeNode > xParentNode( xNode->getParent() );
1075             UnoTreeListEntry* pParentEntry = 0;
1076             sal_uLong nChild = LIST_APPEND;
1077
1078             if( xParentNode.is() )
1079             {
1080                 pParentEntry = getEntry( xParentNode  );
1081                 nChild = xParentNode->getIndex( xNode );
1082             }
1083
1084             pNodeEntry = createEntry( xNode, pParentEntry, nChild );
1085         }
1086
1087         if( bRecursive )
1088             updateChildNodes( rTree, xNode, pNodeEntry );
1089     }
1090 }
1091
1092 void TreeControlPeer::updateChildNodes( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xParentNode, UnoTreeListEntry* pParentEntry )
1093 {
1094     if( xParentNode.is() && pParentEntry )
1095     {
1096         UnoTreeListEntry* pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.FirstChild( pParentEntry ) );
1097
1098         const sal_Int32 nChildCount = xParentNode->getChildCount();
1099         for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ )
1100         {
1101             Reference< XTreeNode > xNode( xParentNode->getChildAt( nChild ) );
1102             if( !pCurrentChild || ( pCurrentChild->mxNode != xNode ) )
1103             {
1104                 UnoTreeListEntry* pNodeEntry = getEntry( xNode, false );
1105                 if( pNodeEntry == 0 )
1106                 {
1107                     // child node is not yet part of the tree, add it
1108                     pCurrentChild = createEntry( xNode, pParentEntry, nChild );
1109                 }
1110                 else if( pNodeEntry != pCurrentChild )
1111                 {
1112                     // node is already part of the tree, but not on the correct position
1113                     rTree.GetModel()->Move( pNodeEntry, pParentEntry, nChild );
1114                     pCurrentChild = pNodeEntry;
1115                     updateEntry( pCurrentChild );
1116                 }
1117             }
1118             else
1119             {
1120                 // child node has entry and entry is equal to current entry,
1121                 // so no structural changes happened
1122                 updateEntry( pCurrentChild );
1123             }
1124
1125             pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) );
1126         }
1127
1128         // check if we have entries without nodes left, we need to remove them
1129         while( pCurrentChild )
1130         {
1131             UnoTreeListEntry* pNextChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) );
1132             rTree.GetModel()->Remove( pCurrentChild );
1133             pCurrentChild = pNextChild;
1134         }
1135     }
1136 }
1137
1138 OUString TreeControlPeer::getEntryString( const Any& rValue )
1139 {
1140     OUString sValue;
1141     if( rValue.hasValue() )
1142     {
1143         switch( rValue.getValueTypeClass() )
1144         {
1145         case TypeClass_SHORT:
1146         case TypeClass_LONG:
1147             {
1148                 sal_Int32 nValue = 0;
1149                 if( rValue >>= nValue )
1150                     sValue = OUString::valueOf( nValue );
1151                 break;
1152             }
1153         case TypeClass_BYTE:
1154         case TypeClass_UNSIGNED_SHORT:
1155         case TypeClass_UNSIGNED_LONG:
1156             {
1157                 sal_uInt32 nValue = 0;
1158                 if( rValue >>= nValue )
1159                     sValue = OUString::valueOf( (sal_Int64)nValue );
1160                 break;
1161             }
1162         case TypeClass_HYPER:
1163             {
1164                 sal_Int64 nValue = 0;
1165                 if( rValue >>= nValue )
1166                     sValue = OUString::valueOf( nValue );
1167                 break;
1168             }
1169         case TypeClass_UNSIGNED_HYPER:
1170             {
1171                 sal_uInt64 nValue = 0;
1172                 if( rValue >>= nValue )
1173                     sValue = OUString::valueOf( (sal_Int64)nValue );
1174                 break;
1175             }
1176         case TypeClass_FLOAT:
1177         case TypeClass_DOUBLE:
1178             {
1179                 double fValue = 0.0;
1180                 if( rValue >>= fValue )
1181                     sValue = OUString::valueOf( fValue );
1182                 break;
1183             }
1184         case TypeClass_STRING:
1185             rValue >>= sValue;
1186             break;
1187     /*
1188         case TypeClass_INTERFACE:
1189             // @todo
1190             break;
1191         case TypeClass_SEQUENCE:
1192             {
1193                 Sequence< Any > aValues;
1194                 if( aValue >>= aValues )
1195                 {
1196                     updateEntry( SvTreeListEntry& rEntry, aValues );
1197                     return;
1198                 }
1199             }
1200             break;
1201     */
1202         default:
1203             break;
1204         }
1205     }
1206     return sValue;
1207 }
1208
1209 // XEventListener
1210 void SAL_CALL TreeControlPeer::disposing( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::uno::RuntimeException)
1211 {
1212     // model is disposed, so we clear our tree
1213     SolarMutexGuard aGuard;
1214     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1215     rTree.Clear();
1216     mxDataModel.clear();
1217 }
1218
1219 void TreeControlPeer::onChangeDataModel( UnoTreeListBoxImpl& rTree, const Reference< XTreeDataModel >& xDataModel )
1220 {
1221     if( xDataModel.is() && (mxDataModel == xDataModel) )
1222         return; // do nothing
1223
1224     Reference< XTreeDataModelListener > xListener( this );
1225
1226     if( mxDataModel.is() )
1227         mxDataModel->removeTreeDataModelListener( xListener );
1228
1229     if( !xDataModel.is() )
1230     {
1231         static const OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.tree.DefaultTreeDataModel" ) );
1232         Reference< XMultiServiceFactory > xORB( ::comphelper::getProcessServiceFactory() );
1233         if( xORB.is() )
1234         {
1235             mxDataModel.query( xORB->createInstance( aSN ) );
1236         }
1237     }
1238
1239     mxDataModel = xDataModel;
1240
1241     fillTree( rTree, mxDataModel );
1242
1243     if( mxDataModel.is() )
1244         mxDataModel->addTreeDataModelListener( xListener );
1245 }
1246
1247 // --------------------------------------------------------------------
1248 // ::com::sun::star::awt::XLayoutConstrains
1249 // --------------------------------------------------------------------
1250
1251 ::com::sun::star::awt::Size TreeControlPeer::getMinimumSize() throw(RuntimeException)
1252 {
1253     SolarMutexGuard aGuard;
1254
1255     ::com::sun::star::awt::Size aSz;
1256 /* todo
1257     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
1258     if ( pEdit )
1259         aSz = AWTSize(pEdit->CalcMinimumSize());
1260 */
1261     return aSz;
1262 }
1263
1264 ::com::sun::star::awt::Size TreeControlPeer::getPreferredSize() throw(RuntimeException)
1265 {
1266     return getMinimumSize();
1267 }
1268
1269 ::com::sun::star::awt::Size TreeControlPeer::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(RuntimeException)
1270 {
1271     SolarMutexGuard aGuard;
1272
1273     ::com::sun::star::awt::Size aSz = rNewSize;
1274 /* todo
1275     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
1276     if ( pEdit )
1277         aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize )));
1278 */
1279     return aSz;
1280 }
1281
1282 // --------------------------------------------------------------------
1283 // ::com::sun::star::awt::XVclWindowPeer
1284 // --------------------------------------------------------------------
1285
1286 void TreeControlPeer::setProperty( const OUString& PropertyName, const Any& aValue) throw(RuntimeException)
1287 {
1288     SolarMutexGuard aGuard;
1289
1290     UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1291
1292     switch( GetPropertyId( PropertyName ) )
1293     {
1294         case BASEPROPERTY_HIDEINACTIVESELECTION:
1295         {
1296             sal_Bool bEnabled = sal_False;
1297             if ( aValue >>= bEnabled )
1298             {
1299                 WinBits nStyle = rTree.GetStyle();
1300                 if ( bEnabled )
1301                     nStyle |= WB_HIDESELECTION;
1302                 else
1303                     nStyle &= ~WB_HIDESELECTION;
1304                 rTree.SetStyle( nStyle );
1305             }
1306         }
1307         break;
1308
1309         case BASEPROPERTY_TREE_SELECTIONTYPE:
1310         {
1311             SelectionType eSelectionType;
1312             if( aValue >>= eSelectionType )
1313             {
1314                 SelectionMode eSelMode;
1315                 switch( eSelectionType )
1316                 {
1317                 case SelectionType_SINGLE:  eSelMode = SINGLE_SELECTION; break;
1318                 case SelectionType_RANGE:   eSelMode = RANGE_SELECTION; break;
1319                 case SelectionType_MULTI:   eSelMode = MULTIPLE_SELECTION; break;
1320     //          case SelectionType_NONE:
1321                 default:                    eSelMode = NO_SELECTION; break;
1322                 }
1323                 if( rTree.GetSelectionMode() != eSelMode )
1324                     rTree.SetSelectionMode( eSelMode );
1325             }
1326             break;
1327         }
1328
1329         case BASEPROPERTY_TREE_DATAMODEL:
1330             onChangeDataModel( rTree, Reference< XTreeDataModel >( aValue, UNO_QUERY ) );
1331             break;
1332         case BASEPROPERTY_ROW_HEIGHT:
1333         {
1334             sal_Int32 nHeight = 0;
1335             if( aValue >>= nHeight )
1336                 rTree.SetEntryHeight( (short)nHeight );
1337             break;
1338         }
1339         case BASEPROPERTY_TREE_EDITABLE:
1340         {
1341             sal_Bool bEnabled = false;
1342             if( aValue >>= bEnabled )
1343                 rTree.EnableInplaceEditing( bEnabled ? sal_True : sal_False );
1344             break;
1345         }
1346         case BASEPROPERTY_TREE_INVOKESSTOPNODEEDITING:
1347             break; // @todo
1348         case BASEPROPERTY_TREE_ROOTDISPLAYED:
1349         {
1350             sal_Bool bDisplayed = false;
1351             if( (aValue >>= bDisplayed) && ( bDisplayed != mbIsRootDisplayed) )
1352             {
1353                 onChangeRootDisplayed(bDisplayed);
1354             }
1355             break;
1356         }
1357         case BASEPROPERTY_TREE_SHOWSHANDLES:
1358         {
1359             sal_Bool bEnabled = false;
1360             if( aValue >>= bEnabled )
1361             {
1362                 WinBits nBits = rTree.GetStyle() & (~WB_HASLINES);
1363                 if( bEnabled )
1364                     nBits |= WB_HASLINES;
1365                 if( nBits != rTree.GetStyle() )
1366                     rTree.SetStyle( nBits );
1367             }
1368             break;
1369         }
1370         case BASEPROPERTY_TREE_SHOWSROOTHANDLES:
1371         {
1372             sal_Bool bEnabled = false;
1373             if( aValue >>= bEnabled )
1374             {
1375                 WinBits nBits = rTree.GetStyle() & (~WB_HASLINESATROOT);
1376                 if( bEnabled )
1377                     nBits |= WB_HASLINESATROOT;
1378                 if( nBits != rTree.GetStyle() )
1379                     rTree.SetStyle( nBits );
1380             }
1381             break;
1382         }
1383         default:
1384         VCLXWindow::setProperty( PropertyName, aValue );
1385         break;
1386     }
1387 }
1388
1389 Any TreeControlPeer::getProperty( const OUString& PropertyName ) throw(RuntimeException)
1390 {
1391     SolarMutexGuard aGuard;
1392
1393     const sal_uInt16 nPropId = GetPropertyId( PropertyName );
1394     if( (nPropId >= BASEPROPERTY_TREE_START) && (nPropId <= BASEPROPERTY_TREE_END) )
1395     {
1396         UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow();
1397         switch(nPropId)
1398         {
1399         case BASEPROPERTY_HIDEINACTIVESELECTION:
1400             return Any( ( rTree.GetStyle() & WB_HIDESELECTION ) != 0 ? sal_True : sal_False );
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_ROW_HEIGHT:
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.GetStyle() & WB_HASLINES) != 0 ? sal_True : sal_False );
1429         case BASEPROPERTY_TREE_SHOWSROOTHANDLES:
1430             return Any( (rTree.GetStyle() & 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 OUString& rURL, Image& rImage )
1459 {
1460     if( !mxGraphicProvider.is() )
1461     {
1462         Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
1463         Reference< XInterface > x( graphic::GraphicProvider::create(xContext) );
1464         mxGraphicProvider.query( x );
1465         mxGraphicProvider = Reference< XGraphicProvider >( x, UNO_QUERY );
1466     }
1467
1468     if( mxGraphicProvider.is() ) try
1469     {
1470         ::com::sun::star::beans::PropertyValues aProps( 1 );
1471         aProps[0].Name = OUString( "URL" );
1472         aProps[0].Value <<= rURL;
1473
1474         Reference< XGraphic > xGraphic( mxGraphicProvider->queryGraphic( aProps ) );
1475
1476         Graphic aGraphic( xGraphic );
1477         rImage = aGraphic.GetBitmapEx();
1478         return true;
1479     }
1480     catch( Exception& )
1481     {
1482     }
1483
1484     return false;
1485 }
1486
1487 // ====================================================================
1488 // class UnoTreeListBoxImpl
1489 // ====================================================================
1490
1491 UnoTreeListBoxImpl::UnoTreeListBoxImpl( TreeControlPeer* pPeer, Window* pParent, WinBits nWinStyle )
1492 : SvTreeListBox( pParent, nWinStyle )
1493 , mxPeer( pPeer )
1494 {
1495     SetStyle( WB_BORDER | WB_HASLINES |WB_HASBUTTONS | WB_HASLINESATROOT | WB_HASBUTTONSATROOT | WB_HSCROLL );
1496     SetNodeDefaultImages();
1497     SetSelectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) );
1498     SetDeselectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) );
1499
1500     SetExpandingHdl( LINK(this, UnoTreeListBoxImpl, OnExpandingHdl) );
1501     SetExpandedHdl( LINK(this, UnoTreeListBoxImpl, OnExpandedHdl) );
1502
1503 }
1504
1505 // --------------------------------------------------------------------
1506
1507 UnoTreeListBoxImpl::~UnoTreeListBoxImpl()
1508 {
1509     if( mxPeer.is() )
1510         mxPeer->disposeControl();
1511 }
1512
1513 // --------------------------------------------------------------------
1514
1515 IMPL_LINK_NOARG(UnoTreeListBoxImpl, OnSelectionChangeHdl)
1516 {
1517     if( mxPeer.is() )
1518         mxPeer->onSelectionChanged();
1519     return 0;
1520 }
1521
1522 // --------------------------------------------------------------------
1523
1524 IMPL_LINK_NOARG(UnoTreeListBoxImpl, OnExpandingHdl)
1525 {
1526     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() );
1527
1528     if( pEntry && mxPeer.is() )
1529     {
1530         return mxPeer->onExpanding( pEntry->mxNode, !IsExpanded( pEntry ) ) ? 1 : 0;
1531     }
1532     return 0;
1533 }
1534
1535 // --------------------------------------------------------------------
1536
1537 IMPL_LINK_NOARG(UnoTreeListBoxImpl, OnExpandedHdl)
1538 {
1539     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() );
1540     if( pEntry && mxPeer.is() )
1541     {
1542         mxPeer->onExpanded( pEntry->mxNode, IsExpanded( pEntry ) );
1543     }
1544     return 0;
1545 }
1546
1547 // --------------------------------------------------------------------
1548
1549 sal_uInt32 UnoTreeListBoxImpl::insert( SvTreeListEntry* pEntry,SvTreeListEntry* pParent,sal_uLong nPos )
1550 {
1551     if( pParent )
1552         return SvTreeListBox::Insert( pEntry, pParent, nPos );
1553     else
1554         return SvTreeListBox::Insert( pEntry, nPos );
1555 }
1556
1557 // --------------------------------------------------------------------
1558
1559 void UnoTreeListBoxImpl::RequestingChildren( SvTreeListEntry* pParent )
1560 {
1561     UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( pParent );
1562     if( pEntry && pEntry->mxNode.is() && mxPeer.is() )
1563         mxPeer->onRequestChildNodes( pEntry->mxNode );
1564 }
1565
1566 // --------------------------------------------------------------------
1567
1568 sal_Bool UnoTreeListBoxImpl::EditingEntry( SvTreeListEntry* pEntry, Selection& )
1569 {
1570     return mxPeer.is() ? mxPeer->onEditingEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ) ) : false;
1571 }
1572
1573 // --------------------------------------------------------------------
1574
1575 sal_Bool UnoTreeListBoxImpl::EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText )
1576 {
1577     return mxPeer.is() ? mxPeer->onEditedEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ), rNewText ) : false;
1578 }
1579
1580 // ====================================================================
1581 // class UnoTreeListItem
1582 // ====================================================================
1583
1584 UnoTreeListItem::UnoTreeListItem( SvTreeListEntry* pEntry )
1585 : SvLBoxString(pEntry, 0, OUString())
1586 {
1587 }
1588
1589 // --------------------------------------------------------------------
1590
1591 UnoTreeListItem::UnoTreeListItem()
1592 : SvLBoxString()
1593 {
1594 }
1595
1596 // --------------------------------------------------------------------
1597
1598 UnoTreeListItem::~UnoTreeListItem()
1599 {
1600 }
1601
1602 // --------------------------------------------------------------------
1603
1604 void UnoTreeListItem::Paint(
1605     const Point& rPos, SvTreeListBox& rDev, const SvViewDataEntry* /*pView*/, const SvTreeListEntry* pEntry)
1606 {
1607     Point aPos( rPos );
1608     if (pEntry)
1609     {
1610         Size aSize( GetSize(&rDev, pEntry) );
1611         if( !!maImage )
1612         {
1613             rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE );
1614             int nWidth = maImage.GetSizePixel().Width() + 6;
1615             aPos.X() += nWidth;
1616             aSize.Width() -= nWidth;
1617         }
1618         rDev.DrawText( Rectangle(aPos,aSize),maText, rDev.IsEnabled() ? 0 : TEXT_DRAW_DISABLE );
1619     }
1620     else
1621     {
1622         if( !!maImage )
1623         {
1624             rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE);
1625             aPos.X() += maImage.GetSizePixel().Width() + 6;
1626         }
1627         rDev.DrawText( aPos, maText);
1628     }
1629 }
1630
1631 // --------------------------------------------------------------------
1632
1633 SvLBoxItem* UnoTreeListItem::Create() const
1634 {
1635     return new UnoTreeListItem;
1636 }
1637
1638 // --------------------------------------------------------------------
1639
1640 void UnoTreeListItem::Clone( SvLBoxItem* pSource )
1641 {
1642     UnoTreeListItem* pSourceItem = dynamic_cast< UnoTreeListItem* >( pSource );
1643     if( pSourceItem )
1644     {
1645         maText = pSourceItem->maText;
1646         maImage = pSourceItem->maImage;
1647     }
1648 }
1649
1650 // --------------------------------------------------------------------
1651
1652 void UnoTreeListItem::SetImage( const Image& rImage )
1653 {
1654     maImage = rImage;
1655 }
1656
1657 // --------------------------------------------------------------------
1658
1659 OUString UnoTreeListItem::GetGraphicURL() const
1660 {
1661     return maGraphicURL;
1662 }
1663
1664 // --------------------------------------------------------------------
1665
1666 void UnoTreeListItem::SetGraphicURL( const OUString& rGraphicURL )
1667 {
1668     maGraphicURL = rGraphicURL;
1669 }
1670
1671 // --------------------------------------------------------------------
1672
1673 void UnoTreeListItem::InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData)
1674 {
1675     if( !pViewData )
1676         pViewData = pView->GetViewDataItem( pEntry, this );
1677
1678     pViewData->maSize = maImage.GetSizePixel();
1679
1680     const Size aTextSize(pView->GetTextWidth( maText ), pView->GetTextHeight());
1681     if( pViewData->maSize.Width() )
1682     {
1683         pViewData->maSize.Width() += 6 + aTextSize.Width();
1684         if( pViewData->maSize.Height() < aTextSize.Height() )
1685             pViewData->maSize.Height() = aTextSize.Height();
1686     }
1687     else
1688     {
1689         pViewData->maSize = aTextSize;
1690     }
1691 }
1692
1693 // --------------------------------------------------------------------
1694
1695 UnoTreeListEntry::UnoTreeListEntry( const Reference< XTreeNode >& xNode, TreeControlPeer* pPeer )
1696 : SvTreeListEntry()
1697 , mxNode( xNode )
1698 , mpPeer( pPeer )
1699 {
1700     if( mpPeer )
1701         mpPeer->addEntry( this );
1702 }
1703
1704 // --------------------------------------------------------------------
1705
1706 UnoTreeListEntry::~UnoTreeListEntry()
1707 {
1708     if( mpPeer )
1709         mpPeer->removeEntry( this );
1710 }
1711
1712 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */