| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #define _SVTREEBX_CXX |
| #include <tools/debug.hxx> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/view/SelectionType.hpp> |
| #include <toolkit/helper/property.hxx> |
| #include <toolkit/helper/vclunohelper.hxx> |
| |
| #include <com/sun/star/awt/tree/XMutableTreeNode.hpp> |
| #include <treecontrolpeer.hxx> |
| #include <comphelper/processfactory.hxx> |
| |
| #include <rtl/ref.hxx> |
| #include <vcl/graph.hxx> |
| #include <svtools/svtreebx.hxx> |
| |
| #include <map> |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::awt::tree; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::view; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::graphic; |
| |
| #define O(x) OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) |
| |
| struct LockGuard |
| { |
| public: |
| LockGuard( sal_Int32& rLock ) |
| : mrLock( rLock ) |
| { |
| rLock++; |
| } |
| |
| ~LockGuard() |
| { |
| mrLock--; |
| } |
| |
| sal_Int32& mrLock; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class ImplGraphicItem : public SvLBoxBmp |
| { |
| public: |
| ImplGraphicItem( SvLBoxEntry* pEntry, sal_uInt16 nFlags, Image& aImage ) : SvLBoxBmp( pEntry, nFlags, aImage ) {} |
| |
| OUString msGraphicURL; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class ImplContextGraphicItem : public SvLBoxContextBmp |
| { |
| public: |
| ImplContextGraphicItem( SvLBoxEntry* pEntry,sal_uInt16 nFlags,Image& rI1,Image& rI2, sal_uInt16 nEntryFlagsBmp1) |
| : SvLBoxContextBmp( pEntry, nFlags, rI1, rI2, nEntryFlagsBmp1 ) {} |
| |
| OUString msExpandedGraphicURL; |
| OUString msCollapsedGraphicURL; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class UnoTreeListBoxImpl : public SvTreeListBox |
| { |
| public: |
| UnoTreeListBoxImpl( TreeControlPeer* pPeer, Window* pParent, WinBits nWinStyle ); |
| ~UnoTreeListBoxImpl(); |
| |
| sal_uInt32 insert( SvLBoxEntry* pEntry,SvLBoxEntry* pParent,sal_uLong nPos=LIST_APPEND ); |
| |
| virtual void RequestingChilds( SvLBoxEntry* pParent ); |
| |
| virtual sal_Bool EditingEntry( SvLBoxEntry* pEntry, Selection& ); |
| virtual sal_Bool EditedEntry( SvLBoxEntry* pEntry, const XubString& rNewText ); |
| |
| DECL_LINK( OnSelectionChangeHdl, UnoTreeListBoxImpl* ); |
| DECL_LINK( OnExpandingHdl, UnoTreeListBoxImpl* ); |
| DECL_LINK( OnExpandedHdl, UnoTreeListBoxImpl* ); |
| |
| private: |
| rtl::Reference< TreeControlPeer > mxPeer; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class SVT_DLLPUBLIC UnoTreeListItem : public SvLBoxItem |
| { |
| public: |
| UnoTreeListItem( SvLBoxEntry* ); |
| UnoTreeListItem(); |
| virtual ~UnoTreeListItem(); |
| virtual sal_uInt16 IsA(); |
| void InitViewData( SvLBox*,SvLBoxEntry*,SvViewDataItem* ); |
| OUString GetText() const; |
| void SetText( const OUString& rText ); |
| Image GetImage() const; |
| void SetImage( const Image& rImage ); |
| OUString GetGraphicURL() const; |
| void SetGraphicURL( const OUString& rGraphicURL ); |
| void Paint( const Point&, SvLBox& rDev, sal_uInt16 nFlags,SvLBoxEntry* ); |
| SvLBoxItem* Create() const; |
| void Clone( SvLBoxItem* pSource ); |
| |
| private: |
| OUString maText; |
| OUString maGraphicURL; |
| Image maImage; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class UnoTreeListEntry : public SvLBoxEntry |
| { |
| public: |
| UnoTreeListEntry( const Reference< XTreeNode >& xNode, TreeControlPeer* pPeer ); |
| virtual ~UnoTreeListEntry(); |
| |
| Reference< XTreeNode > mxNode; |
| TreeControlPeer* mpPeer; |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| class TreeNodeMap : public std::map< Reference< XTreeNode >, UnoTreeListEntry* > |
| { |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| TreeControlPeer::TreeControlPeer() |
| : maSelectionListeners( *this ) |
| , maTreeExpansionListeners( *this ) |
| , maTreeEditListeners( *this ) |
| , mpTreeImpl( 0 ) |
| , mnEditLock( 0 ) |
| , mpTreeNodeMap( 0 ) |
| { |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| TreeControlPeer::~TreeControlPeer() |
| { |
| if( mpTreeImpl ) |
| mpTreeImpl->Clear(); |
| delete mpTreeNodeMap; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::addEntry( UnoTreeListEntry* pEntry ) |
| { |
| if( pEntry && pEntry->mxNode.is() ) |
| { |
| if( !mpTreeNodeMap ) |
| { |
| mpTreeNodeMap = new TreeNodeMap(); |
| } |
| |
| (*mpTreeNodeMap)[ pEntry->mxNode ] = pEntry; |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::removeEntry( UnoTreeListEntry* pEntry ) |
| { |
| if( mpTreeNodeMap && pEntry && pEntry->mxNode.is() ) |
| { |
| TreeNodeMap::iterator aIter( mpTreeNodeMap->find( pEntry->mxNode ) ); |
| if( aIter != mpTreeNodeMap->end() ) |
| { |
| mpTreeNodeMap->erase( aIter ); |
| } |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListEntry* TreeControlPeer::getEntry( const Reference< XTreeNode >& xNode, bool bThrow /* = true */ ) throw( IllegalArgumentException ) |
| { |
| if( mpTreeNodeMap ) |
| { |
| TreeNodeMap::iterator aIter( mpTreeNodeMap->find( xNode ) ); |
| if( aIter != mpTreeNodeMap->end() ) |
| return (*aIter).second; |
| } |
| |
| if( bThrow ) |
| throw IllegalArgumentException(); |
| |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| Window* TreeControlPeer::createVclControl( Window* pParent, sal_Int64 nWinStyle ) |
| { |
| mpTreeImpl = new UnoTreeListBoxImpl( this, pParent, nWinStyle ); |
| return mpTreeImpl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| /** called from the UnoTreeListBoxImpl when it gets deleted */ |
| void TreeControlPeer::disposeControl() |
| { |
| delete mpTreeNodeMap; |
| mpTreeNodeMap = 0; |
| mpTreeImpl = 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::SetWindow( Window* pWindow ) |
| { |
| VCLXWindow::SetWindow( pWindow ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListEntry* TreeControlPeer::createEntry( const Reference< XTreeNode >& xNode, UnoTreeListEntry* pParent, sal_uLong nPos /* = LIST_APPEND */ ) |
| { |
| UnoTreeListEntry* pEntry = 0; |
| if( mpTreeImpl ) |
| { |
| Image aImage; |
| pEntry = new UnoTreeListEntry( xNode, this ); |
| ImplContextGraphicItem* pContextBmp= new ImplContextGraphicItem( pEntry,0, aImage, aImage, SVLISTENTRYFLAG_EXPANDED ); |
| |
| pEntry->AddItem( pContextBmp ); |
| |
| UnoTreeListItem * pUnoItem = new UnoTreeListItem( pEntry ); |
| |
| if( xNode->getNodeGraphicURL().getLength() ) |
| { |
| pUnoItem->SetGraphicURL( xNode->getNodeGraphicURL() ); |
| Image aNodeImage; |
| loadImage( xNode->getNodeGraphicURL(), aNodeImage ); |
| pUnoItem->SetImage( aNodeImage ); |
| mpTreeImpl->AdjustEntryHeight( aNodeImage ); |
| } |
| |
| pEntry->AddItem( pUnoItem ); |
| |
| mpTreeImpl->insert( pEntry, pParent, nPos ); |
| |
| if( msDefaultExpandedGraphicURL.getLength() ) |
| mpTreeImpl->SetExpandedEntryBmp( pEntry, maDefaultExpandedImage ); |
| |
| if( msDefaultCollapsedGraphicURL.getLength() ) |
| mpTreeImpl->SetCollapsedEntryBmp( pEntry, maDefaultCollapsedImage ); |
| |
| updateEntry( pEntry ); |
| } |
| return pEntry; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| bool TreeControlPeer::updateEntry( UnoTreeListEntry* pEntry ) |
| { |
| bool bChanged = false; |
| if( pEntry && pEntry->mxNode.is() && mpTreeImpl ) |
| { |
| const OUString aValue( getEntryString( pEntry->mxNode->getDisplayValue() ) ); |
| UnoTreeListItem* pUnoItem = dynamic_cast< UnoTreeListItem* >( pEntry->GetItem( 1 ) ); |
| if( pUnoItem ) |
| { |
| if( aValue != pUnoItem->GetText() ) |
| { |
| pUnoItem->SetText( aValue ); |
| bChanged = true; |
| } |
| |
| if( pUnoItem->GetGraphicURL() != pEntry->mxNode->getNodeGraphicURL() ) |
| { |
| Image aImage; |
| if( loadImage( pEntry->mxNode->getNodeGraphicURL(), aImage ) ) |
| { |
| pUnoItem->SetGraphicURL( pEntry->mxNode->getNodeGraphicURL() ); |
| pUnoItem->SetImage( aImage ); |
| mpTreeImpl->AdjustEntryHeight( aImage ); |
| bChanged = true; |
| } |
| } |
| } |
| |
| if( (pEntry->mxNode->hasChildrenOnDemand() == sal_True) != (pEntry->HasChildsOnDemand() == sal_True) ) |
| { |
| pEntry->EnableChildsOnDemand( pEntry->mxNode->hasChildrenOnDemand() ? sal_True : sal_False ); |
| bChanged = true; |
| } |
| |
| ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) ); |
| if( pContextGraphicItem ) |
| { |
| if( pContextGraphicItem->msExpandedGraphicURL != pEntry->mxNode->getExpandedGraphicURL() ) |
| { |
| Image aImage; |
| if( loadImage( pEntry->mxNode->getExpandedGraphicURL(), aImage ) ) |
| { |
| pContextGraphicItem->msExpandedGraphicURL = pEntry->mxNode->getExpandedGraphicURL(); |
| mpTreeImpl->SetExpandedEntryBmp( pEntry, aImage ); |
| bChanged = true; |
| } |
| } |
| if( pContextGraphicItem->msCollapsedGraphicURL != pEntry->mxNode->getCollapsedGraphicURL() ) |
| { |
| Image aImage; |
| if( loadImage( pEntry->mxNode->getCollapsedGraphicURL(), aImage ) ) |
| { |
| pContextGraphicItem->msCollapsedGraphicURL = pEntry->mxNode->getCollapsedGraphicURL(); |
| mpTreeImpl->SetCollapsedEntryBmp( pEntry, aImage ); |
| bChanged = true; |
| } |
| } |
| } |
| |
| if( bChanged ) |
| mpTreeImpl->GetModel()->InvalidateEntry( pEntry ); |
| } |
| |
| return bChanged; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::onSelectionChanged() |
| { |
| Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) ); |
| EventObject aEvent( xSource ); |
| maSelectionListeners.selectionChanged( aEvent ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::onRequestChildNodes( const Reference< XTreeNode >& xNode ) |
| { |
| try |
| { |
| Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) ); |
| TreeExpansionEvent aEvent( xSource, xNode ); |
| maTreeExpansionListeners.requestChildNodes( aEvent ); |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| bool TreeControlPeer::onExpanding( const Reference< XTreeNode >& xNode, bool bExpanding ) |
| { |
| try |
| { |
| Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) ); |
| TreeExpansionEvent aEvent( xSource, xNode ); |
| if( bExpanding ) |
| { |
| maTreeExpansionListeners.treeExpanding( aEvent ); |
| } |
| else |
| { |
| maTreeExpansionListeners.treeCollapsing( aEvent ); |
| } |
| } |
| catch( Exception& ) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::onExpanded( const Reference< XTreeNode >& xNode, bool bExpanding ) |
| { |
| try |
| { |
| Reference< XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) ); |
| TreeExpansionEvent aEvent( xSource, xNode ); |
| |
| if( bExpanding ) |
| { |
| maTreeExpansionListeners.treeExpanded( aEvent ); |
| } |
| else |
| { |
| maTreeExpansionListeners.treeCollapsed( aEvent ); |
| } |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::fillTree( UnoTreeListBoxImpl& rTree, const Reference< XTreeDataModel >& xDataModel ) |
| { |
| rTree.Clear(); |
| |
| if( xDataModel.is() ) |
| { |
| Reference< XTreeNode > xRootNode( xDataModel->getRoot() ); |
| if( xRootNode.is() ) |
| { |
| if( mbIsRootDisplayed ) |
| { |
| addNode( rTree, xRootNode, 0 ); |
| } |
| else |
| { |
| const sal_Int32 nChildCount = xRootNode->getChildCount(); |
| for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ ) |
| addNode( rTree, xRootNode->getChildAt( nChild ), 0 ); |
| } |
| } |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::addNode( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xNode, UnoTreeListEntry* pParentEntry ) |
| { |
| if( xNode.is() ) |
| { |
| UnoTreeListEntry* pEntry = createEntry( xNode, pParentEntry, LIST_APPEND ); |
| const sal_Int32 nChildCount = xNode->getChildCount(); |
| for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ ) |
| addNode( rTree, xNode->getChildAt( nChild ), pEntry ); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListBoxImpl& TreeControlPeer::getTreeListBoxOrThrow() const throw (RuntimeException ) |
| { |
| if( !mpTreeImpl ) |
| throw DisposedException(); |
| return *mpTreeImpl; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::ChangeNodesSelection( const Any& rSelection, bool bSelect, bool bSetSelection ) throw( RuntimeException, IllegalArgumentException ) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| Reference< XTreeNode > xTempNode; |
| Sequence< XTreeNode > aTempSeq; |
| |
| const Reference< XTreeNode > *pNodes = 0; |
| sal_Int32 nCount = 0; |
| |
| if( rSelection.hasValue() ) |
| { |
| switch( rSelection.getValueTypeClass() ) |
| { |
| case TypeClass_INTERFACE: |
| { |
| rSelection >>= xTempNode; |
| if( xTempNode.is() ) |
| { |
| nCount = 1; |
| pNodes = &xTempNode; |
| } |
| break; |
| } |
| case TypeClass_SEQUENCE: |
| { |
| if( rSelection.getValueType() == ::getCppuType( (const Sequence< Reference< XTreeNode > > *) 0 ) ) |
| { |
| const Sequence< Reference< XTreeNode > >& rSeq( *(const Sequence< Reference< XTreeNode > > *)rSelection.getValue() ); |
| nCount = rSeq.getLength(); |
| if( nCount ) |
| pNodes = rSeq.getConstArray(); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| |
| if( nCount == 0 ) |
| throw IllegalArgumentException(); |
| } |
| |
| if( bSetSelection ) |
| rTree.SelectAll( sal_False ); |
| |
| if( pNodes && nCount ) |
| { |
| while( nCount-- ) |
| { |
| UnoTreeListEntry* pEntry = getEntry( *pNodes++ ); |
| rTree.Select( pEntry, bSelect ? sal_True : sal_False ); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------- |
| // ::com::sun::star::view::XSelectionSupplier |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::select( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ChangeNodesSelection( rSelection, true, true ); |
| return sal_True; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Any SAL_CALL TreeControlPeer::getSelection() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| Any aRet; |
| |
| sal_uLong nSelectionCount = rTree.GetSelectionCount(); |
| if( nSelectionCount == 1 ) |
| { |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() ); |
| if( pEntry && pEntry->mxNode.is() ) |
| aRet <<= pEntry->mxNode; |
| } |
| else if( nSelectionCount > 1 ) |
| { |
| Sequence< Reference< XTreeNode > > aSelection( nSelectionCount ); |
| Reference< XTreeNode >* pNodes = aSelection.getArray(); |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() ); |
| while( pEntry && nSelectionCount ) |
| { |
| *pNodes++ = pEntry->mxNode; |
| pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) ); |
| --nSelectionCount; |
| } |
| |
| OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) ); |
| aRet <<= aSelection; |
| } |
| |
| return aRet; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::addSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException) |
| { |
| maSelectionListeners.addInterface( xListener ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& xListener ) throw (RuntimeException) |
| { |
| maSelectionListeners.addInterface( xListener ); |
| } |
| |
| // ------------------------------------------------------------------- |
| // ::com::sun::star::view::XMultiSelectionSupplier |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::addSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException) |
| { |
| ChangeNodesSelection( rSelection, true, false ); |
| return sal_True; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::removeSelection( const Any& rSelection ) throw (IllegalArgumentException, RuntimeException) |
| { |
| ChangeNodesSelection( rSelection, false, false ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::clearSelection() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| getTreeListBoxOrThrow().SelectAll( sal_False ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL TreeControlPeer::getSelectionCount() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| return getTreeListBoxOrThrow().GetSelectionCount(); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| class TreeSelectionEnumeration : public ::cppu::WeakImplHelper1< XEnumeration > |
| { |
| public: |
| TreeSelectionEnumeration( std::list< Any >& rSelection ); |
| virtual ::sal_Bool SAL_CALL hasMoreElements() throw (RuntimeException); |
| virtual Any SAL_CALL nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException); |
| |
| std::list< Any > maSelection; |
| std::list< Any >::iterator maIter; |
| }; |
| |
| // ------------------------------------------------------------------- |
| |
| TreeSelectionEnumeration::TreeSelectionEnumeration( std::list< Any >& rSelection ) |
| { |
| maSelection.swap( rSelection ); |
| maIter = maSelection.begin(); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| ::sal_Bool SAL_CALL TreeSelectionEnumeration::hasMoreElements() throw (RuntimeException) |
| { |
| return maIter != maSelection.end(); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Any SAL_CALL TreeSelectionEnumeration::nextElement() throw (NoSuchElementException, WrappedTargetException, RuntimeException) |
| { |
| if( maIter == maSelection.end() ) |
| throw NoSuchElementException(); |
| |
| return (*maIter++); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Reference< XEnumeration > SAL_CALL TreeControlPeer::createSelectionEnumeration() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| sal_uInt32 nSelectionCount = rTree.GetSelectionCount(); |
| std::list< Any > aSelection( nSelectionCount ); |
| |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() ); |
| while( pEntry && nSelectionCount ) |
| { |
| aSelection.push_back( Any( pEntry->mxNode ) ); |
| pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) ); |
| --nSelectionCount; |
| } |
| |
| OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) ); |
| |
| return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Reference< XEnumeration > SAL_CALL TreeControlPeer::createReverseSelectionEnumeration() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| sal_uInt32 nSelectionCount = rTree.GetSelectionCount(); |
| std::list< Any > aSelection; |
| |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.FirstSelected() ); |
| while( pEntry && nSelectionCount ) |
| { |
| aSelection.push_front( Any( pEntry->mxNode ) ); |
| pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.NextSelected( pEntry ) ); |
| --nSelectionCount; |
| } |
| |
| OSL_ASSERT( (pEntry == 0) && (nSelectionCount == 0) ); |
| |
| return Reference< XEnumeration >( new TreeSelectionEnumeration( aSelection ) ); |
| } |
| |
| // -------------------------------------------------------------------- |
| // ::com::sun::star::awt::XTreeControl |
| // -------------------------------------------------------------------- |
| |
| OUString SAL_CALL TreeControlPeer::getDefaultExpandedGraphicURL() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| return msDefaultExpandedGraphicURL; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::setDefaultExpandedGraphicURL( const ::rtl::OUString& sDefaultExpandedGraphicURL ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| if( msDefaultExpandedGraphicURL != sDefaultExpandedGraphicURL ) |
| { |
| if( sDefaultExpandedGraphicURL.getLength() ) |
| loadImage( sDefaultExpandedGraphicURL, maDefaultExpandedImage ); |
| else |
| maDefaultExpandedImage = Image(); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| SvLBoxEntry* pEntry = rTree.First(); |
| while( pEntry ) |
| { |
| ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) ); |
| if( pContextGraphicItem ) |
| { |
| if( pContextGraphicItem->msExpandedGraphicURL.getLength() == 0 ) |
| rTree.SetExpandedEntryBmp( pEntry, maDefaultExpandedImage ); |
| } |
| pEntry = rTree.Next( pEntry ); |
| } |
| |
| msDefaultExpandedGraphicURL = sDefaultExpandedGraphicURL; |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| OUString SAL_CALL TreeControlPeer::getDefaultCollapsedGraphicURL() throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| return msDefaultCollapsedGraphicURL; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::setDefaultCollapsedGraphicURL( const ::rtl::OUString& sDefaultCollapsedGraphicURL ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| if( msDefaultCollapsedGraphicURL != sDefaultCollapsedGraphicURL ) |
| { |
| if( sDefaultCollapsedGraphicURL.getLength() ) |
| loadImage( sDefaultCollapsedGraphicURL, maDefaultCollapsedImage ); |
| else |
| maDefaultCollapsedImage = Image(); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| SvLBoxEntry* pEntry = rTree.First(); |
| while( pEntry ) |
| { |
| ImplContextGraphicItem* pContextGraphicItem = dynamic_cast< ImplContextGraphicItem* >( pEntry->GetItem( 0 ) ); |
| if( pContextGraphicItem ) |
| { |
| if( pContextGraphicItem->msCollapsedGraphicURL.getLength() == 0 ) |
| rTree.SetCollapsedEntryBmp( pEntry, maDefaultCollapsedImage ); |
| } |
| pEntry = rTree.Next( pEntry ); |
| } |
| |
| msDefaultCollapsedGraphicURL = sDefaultCollapsedGraphicURL; |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::isNodeExpanded( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| return ( pEntry && rTree.IsExpanded( pEntry ) ) ? sal_True : sal_False; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::isNodeCollapsed( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| return !isNodeExpanded( xNode ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::makeNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| if( pEntry ) |
| rTree.MakeVisible( pEntry ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::isNodeVisible( const Reference< XTreeNode >& xNode ) throw (RuntimeException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| return ( pEntry && rTree.IsEntryVisible( pEntry ) ) ? sal_True : sal_False; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::expandNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| if( pEntry ) |
| rTree.Expand( pEntry ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::collapseNode( const Reference< XTreeNode >& xNode ) throw (RuntimeException, ExpandVetoException, IllegalArgumentException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| if( pEntry ) |
| rTree.Collapse( pEntry ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::addTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException) |
| { |
| maTreeExpansionListeners.addInterface( xListener ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::removeTreeExpansionListener( const Reference< XTreeExpansionListener >& xListener ) throw (RuntimeException) |
| { |
| maTreeExpansionListeners.removeInterface( xListener ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Reference< XTreeNode > SAL_CALL TreeControlPeer::getNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| Reference< XTreeNode > xNode; |
| |
| const Point aPos( x, y ); |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, sal_True ) ); |
| if( pEntry ) |
| xNode = pEntry->mxNode; |
| |
| return xNode; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| Reference< XTreeNode > SAL_CALL TreeControlPeer::getClosestNodeForLocation( sal_Int32 x, sal_Int32 y ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| Reference< XTreeNode > xNode; |
| |
| const Point aPos( x, y ); |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( rTree.GetEntry( aPos, sal_True ) ); |
| if( pEntry ) |
| xNode = pEntry->mxNode; |
| |
| return xNode; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| awt::Rectangle SAL_CALL TreeControlPeer::getNodeRect( const Reference< XTreeNode >& i_Node ) throw (IllegalArgumentException, RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( i_Node, true ); |
| |
| ::Rectangle aEntryRect( rTree.GetFocusRect( pEntry, rTree.GetEntryPosition( pEntry ).Y() ) ); |
| return VCLUnoHelper::ConvertToAWTRect( aEntryRect ); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::isEditing( ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| return rTree.IsEditingActive() ? sal_True : sal_False; |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| sal_Bool SAL_CALL TreeControlPeer::stopEditing() throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| if( rTree.IsEditingActive() ) |
| { |
| rTree.EndEditing(sal_False); |
| return sal_True; |
| } |
| else |
| { |
| return sal_False; |
| } |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::cancelEditing( ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| rTree.EndEditing(sal_False); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::startEditingAtNode( const Reference< XTreeNode >& xNode ) throw (IllegalArgumentException, RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| UnoTreeListEntry* pEntry = getEntry( xNode ); |
| rTree.EditEntry( pEntry ); |
| } |
| |
| void SAL_CALL TreeControlPeer::addTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException) |
| { |
| maTreeEditListeners.addInterface( xListener ); |
| } |
| |
| void SAL_CALL TreeControlPeer::removeTreeEditListener( const Reference< XTreeEditListener >& xListener ) throw (RuntimeException) |
| { |
| maTreeEditListeners.removeInterface( xListener ); |
| } |
| |
| bool TreeControlPeer::onEditingEntry( UnoTreeListEntry* pEntry ) |
| { |
| if( mpTreeImpl && pEntry && pEntry->mxNode.is() && (maTreeEditListeners.getLength() > 0) ) |
| { |
| try |
| { |
| maTreeEditListeners.nodeEditing( pEntry->mxNode ); |
| } |
| catch( VetoException& ) |
| { |
| return false; |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| return true; |
| } |
| |
| bool TreeControlPeer::onEditedEntry( UnoTreeListEntry* pEntry, const XubString& rNewText ) |
| { |
| if( mpTreeImpl && pEntry && pEntry->mxNode.is() ) try |
| { |
| LockGuard aLockGuard( mnEditLock ); |
| const OUString aNewText( rNewText ); |
| if( maTreeEditListeners.getLength() > 0 ) |
| { |
| maTreeEditListeners.nodeEdited( pEntry->mxNode, aNewText ); |
| return false; |
| } |
| else |
| { |
| Reference< XMutableTreeNode > xMutableNode( pEntry->mxNode, UNO_QUERY ); |
| if( xMutableNode.is() ) |
| xMutableNode->setDisplayValue( Any( aNewText ) ); |
| else |
| return false; |
| } |
| |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| return true; |
| } |
| |
| // -------------------------------------------------------------------- |
| // ::com::sun::star::awt::tree::TreeDataModelListener |
| // -------------------------------------------------------------------- |
| |
| void SAL_CALL TreeControlPeer::treeNodesChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| if( mnEditLock != 0 ) |
| return; |
| |
| updateTree( rEvent, true ); |
| } |
| |
| void SAL_CALL TreeControlPeer::treeNodesInserted( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| if( mnEditLock != 0 ) |
| return; |
| |
| updateTree( rEvent, true ); |
| } |
| |
| void SAL_CALL TreeControlPeer::treeNodesRemoved( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| if( mnEditLock != 0 ) |
| return; |
| |
| updateTree( rEvent, true ); |
| } |
| |
| void SAL_CALL TreeControlPeer::treeStructureChanged( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| if( mnEditLock != 0 ) |
| return; |
| |
| updateTree( rEvent, true ); |
| } |
| |
| void TreeControlPeer::updateTree( const ::com::sun::star::awt::tree::TreeDataModelEvent& rEvent, bool bRecursive ) |
| { |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| Sequence< Reference< XTreeNode > > Nodes; |
| Reference< XTreeNode > xNode( rEvent.ParentNode ); |
| if( !xNode.is() && Nodes.getLength() ) |
| { |
| xNode = Nodes[0]; |
| } |
| |
| if( xNode.is() ) |
| updateNode( rTree, xNode, bRecursive ); |
| } |
| |
| void TreeControlPeer::updateNode( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xNode, bool bRecursive ) |
| { |
| if( xNode.is() ) |
| { |
| UnoTreeListEntry* pNodeEntry = getEntry( xNode, false ); |
| |
| if( !pNodeEntry ) |
| { |
| Reference< XTreeNode > xParentNode( xNode->getParent() ); |
| UnoTreeListEntry* pParentEntry = 0; |
| sal_uLong nChild = LIST_APPEND; |
| |
| if( xParentNode.is() ) |
| { |
| pParentEntry = getEntry( xParentNode ); |
| nChild = xParentNode->getIndex( xNode ); |
| } |
| |
| pNodeEntry = createEntry( xNode, pParentEntry, nChild ); |
| } |
| |
| if( bRecursive ) |
| updateChildNodes( rTree, xNode, pNodeEntry ); |
| } |
| } |
| |
| void TreeControlPeer::updateChildNodes( UnoTreeListBoxImpl& rTree, const Reference< XTreeNode >& xParentNode, UnoTreeListEntry* pParentEntry ) |
| { |
| if( xParentNode.is() && pParentEntry ) |
| { |
| UnoTreeListEntry* pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.FirstChild( pParentEntry ) ); |
| |
| const sal_Int32 nChildCount = xParentNode->getChildCount(); |
| for( sal_Int32 nChild = 0; nChild < nChildCount; nChild++ ) |
| { |
| Reference< XTreeNode > xNode( xParentNode->getChildAt( nChild ) ); |
| if( !pCurrentChild || ( pCurrentChild->mxNode != xNode ) ) |
| { |
| UnoTreeListEntry* pNodeEntry = getEntry( xNode, false ); |
| if( pNodeEntry == 0 ) |
| { |
| // child node is not yet part of the tree, add it |
| pCurrentChild = createEntry( xNode, pParentEntry, nChild ); |
| } |
| else if( pNodeEntry != pCurrentChild ) |
| { |
| // node is already part of the tree, but not on the correct position |
| rTree.GetModel()->Move( pNodeEntry, pParentEntry, nChild ); |
| pCurrentChild = pNodeEntry; |
| updateEntry( pCurrentChild ); |
| } |
| } |
| else |
| { |
| // child node has entry and entry is equal to current entry, |
| // so no structural changes happened |
| updateEntry( pCurrentChild ); |
| } |
| |
| pCurrentChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) ); |
| } |
| |
| // check if we have entries without nodes left, we need to remove them |
| while( pCurrentChild ) |
| { |
| UnoTreeListEntry* pNextChild = dynamic_cast< UnoTreeListEntry* >( rTree.NextSibling( pCurrentChild ) ); |
| rTree.GetModel()->Remove( pCurrentChild ); |
| pCurrentChild = pNextChild; |
| } |
| } |
| } |
| |
| OUString TreeControlPeer::getEntryString( const Any& rValue ) |
| { |
| OUString sValue; |
| if( rValue.hasValue() ) |
| { |
| switch( rValue.getValueTypeClass() ) |
| { |
| case TypeClass_SHORT: |
| case TypeClass_LONG: |
| { |
| sal_Int32 nValue = 0; |
| if( rValue >>= nValue ) |
| sValue = OUString::valueOf( nValue ); |
| break; |
| } |
| case TypeClass_BYTE: |
| case TypeClass_UNSIGNED_SHORT: |
| case TypeClass_UNSIGNED_LONG: |
| { |
| sal_uInt32 nValue = 0; |
| if( rValue >>= nValue ) |
| sValue = OUString::valueOf( (sal_Int64)nValue ); |
| break; |
| } |
| case TypeClass_HYPER: |
| { |
| sal_Int64 nValue = 0; |
| if( rValue >>= nValue ) |
| sValue = OUString::valueOf( nValue ); |
| break; |
| } |
| case TypeClass_UNSIGNED_HYPER: |
| { |
| sal_uInt64 nValue = 0; |
| if( rValue >>= nValue ) |
| sValue = OUString::valueOf( (sal_Int64)nValue ); |
| break; |
| } |
| case TypeClass_FLOAT: |
| case TypeClass_DOUBLE: |
| { |
| double fValue = 0.0; |
| if( rValue >>= fValue ) |
| sValue = OUString::valueOf( fValue ); |
| break; |
| } |
| case TypeClass_STRING: |
| rValue >>= sValue; |
| break; |
| /* |
| case TypeClass_INTERFACE: |
| // @todo |
| break; |
| case TypeClass_SEQUENCE: |
| { |
| Sequence< Any > aValues; |
| if( aValue >>= aValues ) |
| { |
| updateEntry( SvLBoxEntry& rEntry, aValues ); |
| return; |
| } |
| } |
| break; |
| */ |
| default: |
| break; |
| } |
| } |
| return sValue; |
| } |
| |
| // XEventListener |
| void SAL_CALL TreeControlPeer::disposing( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| // model is disposed, so we clear our tree |
| ::vos::OGuard aGuard( GetMutex() ); |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| rTree.Clear(); |
| mxDataModel.clear(); |
| } |
| |
| void TreeControlPeer::onChangeDataModel( UnoTreeListBoxImpl& rTree, const Reference< XTreeDataModel >& xDataModel ) |
| { |
| if( xDataModel.is() && (mxDataModel == xDataModel) ) |
| return; // do nothing |
| |
| Reference< XTreeDataModelListener > xListener( this ); |
| |
| if( mxDataModel.is() ) |
| mxDataModel->removeTreeDataModelListener( xListener ); |
| |
| if( !xDataModel.is() ) |
| { |
| static const OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.tree.DefaultTreeDataModel" ) ); |
| Reference< XMultiServiceFactory > xORB( ::comphelper::getProcessServiceFactory() ); |
| if( xORB.is() ) |
| { |
| mxDataModel.query( xORB->createInstance( aSN ) ); |
| } |
| } |
| |
| mxDataModel = xDataModel; |
| |
| fillTree( rTree, mxDataModel ); |
| |
| if( mxDataModel.is() ) |
| mxDataModel->addTreeDataModelListener( xListener ); |
| } |
| |
| // -------------------------------------------------------------------- |
| // ::com::sun::star::awt::XLayoutConstrains |
| // -------------------------------------------------------------------- |
| |
| ::com::sun::star::awt::Size TreeControlPeer::getMinimumSize() throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz; |
| /* todo |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| aSz = AWTSize(pEdit->CalcMinimumSize()); |
| */ |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size TreeControlPeer::getPreferredSize() throw(RuntimeException) |
| { |
| return getMinimumSize(); |
| } |
| |
| ::com::sun::star::awt::Size TreeControlPeer::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz = rNewSize; |
| /* todo |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize ))); |
| */ |
| return aSz; |
| } |
| |
| // -------------------------------------------------------------------- |
| // ::com::sun::star::awt::XVclWindowPeer |
| // -------------------------------------------------------------------- |
| |
| void TreeControlPeer::setProperty( const ::rtl::OUString& PropertyName, const Any& aValue) throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| switch( GetPropertyId( PropertyName ) ) |
| { |
| case BASEPROPERTY_HIDEINACTIVESELECTION: |
| { |
| sal_Bool bEnabled = sal_False; |
| if ( aValue >>= bEnabled ) |
| { |
| WinBits nStyle = rTree.GetStyle(); |
| if ( bEnabled ) |
| nStyle |= WB_HIDESELECTION; |
| else |
| nStyle &= ~WB_HIDESELECTION; |
| rTree.SetStyle( nStyle ); |
| } |
| } |
| break; |
| |
| case BASEPROPERTY_TREE_SELECTIONTYPE: |
| { |
| SelectionType eSelectionType; |
| if( aValue >>= eSelectionType ) |
| { |
| SelectionMode eSelMode; |
| switch( eSelectionType ) |
| { |
| case SelectionType_SINGLE: eSelMode = SINGLE_SELECTION; break; |
| case SelectionType_RANGE: eSelMode = RANGE_SELECTION; break; |
| case SelectionType_MULTI: eSelMode = MULTIPLE_SELECTION; break; |
| // case SelectionType_NONE: |
| default: eSelMode = NO_SELECTION; break; |
| } |
| if( rTree.GetSelectionMode() != eSelMode ) |
| rTree.SetSelectionMode( eSelMode ); |
| } |
| break; |
| } |
| |
| case BASEPROPERTY_TREE_DATAMODEL: |
| onChangeDataModel( rTree, Reference< XTreeDataModel >( aValue, UNO_QUERY ) ); |
| break; |
| case BASEPROPERTY_ROW_HEIGHT: |
| { |
| sal_Int32 nHeight = 0; |
| if( aValue >>= nHeight ) |
| rTree.SetEntryHeight( (short)nHeight ); |
| break; |
| } |
| case BASEPROPERTY_TREE_EDITABLE: |
| { |
| sal_Bool bEnabled = false; |
| if( aValue >>= bEnabled ) |
| rTree.EnableInplaceEditing( bEnabled ? sal_True : sal_False ); |
| break; |
| } |
| case BASEPROPERTY_TREE_INVOKESSTOPNODEEDITING: |
| break; // @todo |
| case BASEPROPERTY_TREE_ROOTDISPLAYED: |
| { |
| sal_Bool bDisplayed = false; |
| if( (aValue >>= bDisplayed) && ( bDisplayed != mbIsRootDisplayed) ) |
| { |
| onChangeRootDisplayed(bDisplayed); |
| } |
| break; |
| } |
| case BASEPROPERTY_TREE_SHOWSHANDLES: |
| { |
| sal_Bool bEnabled = false; |
| if( aValue >>= bEnabled ) |
| { |
| WinBits nBits = rTree.GetStyle() & (~WB_HASLINES); |
| if( bEnabled ) |
| nBits |= WB_HASLINES; |
| if( nBits != rTree.GetStyle() ) |
| rTree.SetStyle( nBits ); |
| } |
| break; |
| } |
| case BASEPROPERTY_TREE_SHOWSROOTHANDLES: |
| { |
| sal_Bool bEnabled = false; |
| if( aValue >>= bEnabled ) |
| { |
| WinBits nBits = rTree.GetStyle() & (~WB_HASLINESATROOT); |
| if( bEnabled ) |
| nBits |= WB_HASLINESATROOT; |
| if( nBits != rTree.GetStyle() ) |
| rTree.SetStyle( nBits ); |
| } |
| break; |
| } |
| default: |
| VCLXWindow::setProperty( PropertyName, aValue ); |
| break; |
| } |
| } |
| |
| Any TreeControlPeer::getProperty( const ::rtl::OUString& PropertyName ) throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| const sal_uInt16 nPropId = GetPropertyId( PropertyName ); |
| if( (nPropId >= BASEPROPERTY_TREE_START) && (nPropId <= BASEPROPERTY_TREE_END) ) |
| { |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| switch(nPropId) |
| { |
| case BASEPROPERTY_HIDEINACTIVESELECTION: |
| return Any( ( rTree.GetStyle() & WB_HIDESELECTION ) != 0 ? sal_True : sal_False ); |
| |
| case BASEPROPERTY_TREE_SELECTIONTYPE: |
| { |
| SelectionType eSelectionType; |
| |
| SelectionMode eSelMode = rTree.GetSelectionMode(); |
| switch( eSelMode ) |
| { |
| case SINGLE_SELECTION: eSelectionType = SelectionType_SINGLE; break; |
| case RANGE_SELECTION: eSelectionType = SelectionType_RANGE; break; |
| case MULTIPLE_SELECTION:eSelectionType = SelectionType_MULTI; break; |
| // case NO_SELECTION: |
| default: eSelectionType = SelectionType_NONE; break; |
| } |
| return Any( eSelectionType ); |
| } |
| case BASEPROPERTY_ROW_HEIGHT: |
| return Any( (sal_Int32)rTree.GetEntryHeight() ); |
| case BASEPROPERTY_TREE_DATAMODEL: |
| return Any( mxDataModel ); |
| case BASEPROPERTY_TREE_EDITABLE: |
| return Any( rTree.IsInplaceEditingEnabled() ? sal_True : sal_False ); |
| case BASEPROPERTY_TREE_INVOKESSTOPNODEEDITING: |
| return Any( sal_True ); // @todo |
| case BASEPROPERTY_TREE_ROOTDISPLAYED: |
| return Any( mbIsRootDisplayed ); |
| case BASEPROPERTY_TREE_SHOWSHANDLES: |
| return Any( (rTree.GetStyle() & WB_HASLINES) != 0 ? sal_True : sal_False ); |
| case BASEPROPERTY_TREE_SHOWSROOTHANDLES: |
| return Any( (rTree.GetStyle() & WB_HASLINESATROOT) != 0 ? sal_True : sal_False ); |
| } |
| } |
| return VCLXWindow::getProperty( PropertyName ); |
| } |
| |
| void TreeControlPeer::onChangeRootDisplayed( sal_Bool bIsRootDisplayed ) |
| { |
| if( mbIsRootDisplayed == bIsRootDisplayed ) |
| return; |
| |
| mbIsRootDisplayed = bIsRootDisplayed; |
| |
| UnoTreeListBoxImpl& rTree = getTreeListBoxOrThrow(); |
| |
| if( rTree.GetEntryCount() == 0 ) |
| return; |
| |
| // todo |
| fillTree( rTree, mxDataModel ); |
| if( mbIsRootDisplayed ) |
| { |
| } |
| else |
| { |
| } |
| } |
| |
| bool TreeControlPeer::loadImage( const ::rtl::OUString& rURL, Image& rImage ) |
| { |
| if( !mxGraphicProvider.is() ) |
| { |
| static const OUString aSN( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicProvider" ) ); |
| Reference< XMultiServiceFactory > xORB( ::comphelper::getProcessServiceFactory() ); |
| if( xORB.is() ) |
| { |
| Reference< XInterface > x( xORB->createInstance( aSN ) ); |
| mxGraphicProvider.query( x ); |
| mxGraphicProvider = Reference< XGraphicProvider >( x, UNO_QUERY ); |
| } |
| } |
| |
| if( mxGraphicProvider.is() ) try |
| { |
| ::com::sun::star::beans::PropertyValues aProps( 1 ); |
| aProps[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ); |
| aProps[0].Value <<= rURL; |
| |
| Reference< XGraphic > xGraphic( mxGraphicProvider->queryGraphic( aProps ) ); |
| |
| Graphic aGraphic( xGraphic ); |
| rImage = aGraphic.GetBitmapEx(); |
| return true; |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| return false; |
| } |
| |
| // ==================================================================== |
| // class UnoTreeListBoxImpl |
| // ==================================================================== |
| |
| UnoTreeListBoxImpl::UnoTreeListBoxImpl( TreeControlPeer* pPeer, Window* pParent, WinBits nWinStyle ) |
| : SvTreeListBox( pParent, nWinStyle ) |
| , mxPeer( pPeer ) |
| { |
| SetStyle( WB_BORDER | WB_HASLINES |WB_HASBUTTONS | WB_HASLINESATROOT | WB_HASBUTTONSATROOT | WB_HSCROLL ); |
| SetNodeDefaultImages(); |
| SetSelectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) ); |
| SetDeselectHdl( LINK(this, UnoTreeListBoxImpl, OnSelectionChangeHdl) ); |
| |
| SetExpandingHdl( LINK(this, UnoTreeListBoxImpl, OnExpandingHdl) ); |
| SetExpandedHdl( LINK(this, UnoTreeListBoxImpl, OnExpandedHdl) ); |
| |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListBoxImpl::~UnoTreeListBoxImpl() |
| { |
| if( mxPeer.is() ) |
| mxPeer->disposeControl(); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK( UnoTreeListBoxImpl, OnSelectionChangeHdl, UnoTreeListBoxImpl*, EMPTYARG ) |
| { |
| if( mxPeer.is() ) |
| mxPeer->onSelectionChanged(); |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK(UnoTreeListBoxImpl, OnExpandingHdl, UnoTreeListBoxImpl*, EMPTYARG ) |
| { |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() ); |
| |
| if( pEntry && mxPeer.is() ) |
| { |
| return mxPeer->onExpanding( pEntry->mxNode, !IsExpanded( pEntry ) ) ? 1 : 0; |
| } |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| IMPL_LINK(UnoTreeListBoxImpl, OnExpandedHdl, UnoTreeListBoxImpl*, EMPTYARG ) |
| { |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( GetHdlEntry() ); |
| if( pEntry && mxPeer.is() ) |
| { |
| mxPeer->onExpanded( pEntry->mxNode, IsExpanded( pEntry ) ); |
| } |
| return 0; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| sal_uInt32 UnoTreeListBoxImpl::insert( SvLBoxEntry* pEntry,SvLBoxEntry* pParent,sal_uLong nPos ) |
| { |
| if( pParent ) |
| return SvTreeListBox::Insert( pEntry, pParent, nPos ); |
| else |
| return SvTreeListBox::Insert( pEntry, nPos ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListBoxImpl::RequestingChilds( SvLBoxEntry* pParent ) |
| { |
| UnoTreeListEntry* pEntry = dynamic_cast< UnoTreeListEntry* >( pParent ); |
| if( pEntry && pEntry->mxNode.is() && mxPeer.is() ) |
| mxPeer->onRequestChildNodes( pEntry->mxNode ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| sal_Bool UnoTreeListBoxImpl::EditingEntry( SvLBoxEntry* pEntry, Selection& ) |
| { |
| return mxPeer.is() ? mxPeer->onEditingEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ) ) : false; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| sal_Bool UnoTreeListBoxImpl::EditedEntry( SvLBoxEntry* pEntry, const XubString& rNewText ) |
| { |
| return mxPeer.is() ? mxPeer->onEditedEntry( dynamic_cast< UnoTreeListEntry* >( pEntry ), rNewText ) : false; |
| } |
| |
| // ==================================================================== |
| // class UnoTreeListItem |
| // ==================================================================== |
| |
| UnoTreeListItem::UnoTreeListItem( SvLBoxEntry* pEntry ) |
| : SvLBoxItem( pEntry, 0 ) |
| { |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListItem::UnoTreeListItem() |
| : SvLBoxItem() |
| { |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListItem::~UnoTreeListItem() |
| { |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| sal_uInt16 UnoTreeListItem::IsA() |
| { |
| return SV_ITEM_ID_LBOXSTRING; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 /* nFlags */, SvLBoxEntry* _pEntry) |
| { |
| Point aPos( rPos ); |
| if( _pEntry ) |
| { |
| Size aSize( GetSize(&rDev,_pEntry) ); |
| if( !!maImage ) |
| { |
| rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE ); |
| int nWidth = maImage.GetSizePixel().Width() + 6; |
| aPos.X() += nWidth; |
| aSize.Width() -= nWidth; |
| } |
| rDev.DrawText( Rectangle(aPos,aSize),maText, rDev.IsEnabled() ? 0 : TEXT_DRAW_DISABLE ); |
| } |
| else |
| { |
| if( !!maImage ) |
| { |
| rDev.DrawImage( aPos, maImage, rDev.IsEnabled() ? 0 : IMAGE_DRAW_DISABLE); |
| aPos.X() += maImage.GetSizePixel().Width() + 6; |
| } |
| rDev.DrawText( aPos, maText); |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| SvLBoxItem* UnoTreeListItem::Create() const |
| { |
| return new UnoTreeListItem; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::Clone( SvLBoxItem* pSource ) |
| { |
| UnoTreeListItem* pSourceItem = dynamic_cast< UnoTreeListItem* >( pSource ); |
| if( pSourceItem ) |
| { |
| maText = pSourceItem->maText; |
| maImage = pSourceItem->maImage; |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| OUString UnoTreeListItem::GetText() const |
| { |
| return maText; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::SetText( const OUString& rText ) |
| { |
| maText = rText; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::SetImage( const Image& rImage ) |
| { |
| maImage = rImage; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| OUString UnoTreeListItem::GetGraphicURL() const |
| { |
| return maGraphicURL; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::SetGraphicURL( const OUString& rGraphicURL ) |
| { |
| maGraphicURL = rGraphicURL; |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| void UnoTreeListItem::InitViewData( SvLBox* pView,SvLBoxEntry* pEntry, SvViewDataItem* pViewData) |
| { |
| if( !pViewData ) |
| pViewData = pView->GetViewDataItem( pEntry, this ); |
| |
| pViewData->aSize = maImage.GetSizePixel(); |
| |
| const Size aTextSize(pView->GetTextWidth( maText ), pView->GetTextHeight()); |
| if( pViewData->aSize.Width() ) |
| { |
| pViewData->aSize.Width() += 6 + aTextSize.Width(); |
| if( pViewData->aSize.Height() < aTextSize.Height() ) |
| pViewData->aSize.Height() = aTextSize.Height(); |
| } |
| else |
| { |
| pViewData->aSize = aTextSize; |
| } |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListEntry::UnoTreeListEntry( const Reference< XTreeNode >& xNode, TreeControlPeer* pPeer ) |
| : SvLBoxEntry() |
| , mxNode( xNode ) |
| , mpPeer( pPeer ) |
| { |
| if( mpPeer ) |
| mpPeer->addEntry( this ); |
| } |
| |
| // -------------------------------------------------------------------- |
| |
| UnoTreeListEntry::~UnoTreeListEntry() |
| { |
| if( mpPeer ) |
| mpPeer->removeEntry( this ); |
| } |
