// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.widgets;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.core.util.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.resources.client.*;
import com.google.gwt.user.client.ui.*;

public class SizeableTree extends AbstractSizeableComposite implements TreeNode
{
    public static final String FOLDER_OPEN_URL = "common/images/misc/folder_open_16x16.gif";
    public static final String FOLDER_CLOSED_URL = "common/images/misc/folder_closed_16x16.gif";
    public static final String FOLDER_LEAF_URL = "common/images/misc/TransparentSpacer_16x16.gif";

    protected final Tree mTree;
    protected SizeableScrollPanel mScrollPanel;

    private SizeableTree( Tree pTree )
    {
        mTree = pTree;
        initWidget( mScrollPanel = new SizeableScrollPanel( mTree ) );
        LLstretchable();
        mTree.addSelectionHandler( new SelectionHandler<TreeItem>()
        {
            @Override public void onSelection( SelectionEvent<TreeItem> event )
            {
                notifySelectionChange();
            }
        } );
        mTree.addOpenHandler( new OpenHandler<TreeItem>()
        {
            @Override public void onOpen( OpenEvent<TreeItem> event )
            {
                notifyOpenCloseChange( true );
            }
        } );
        mTree.addCloseHandler( new CloseHandler<TreeItem>()
        {
            @Override public void onClose( CloseEvent<TreeItem> event )
            {
                notifyOpenCloseChange( false );
            }
        } );
    }

    public SizeableTree()
    {
        this( new Tree() );
    }

    public SizeableTree( String pOpenImageURL, int pOpenWidth, int pOpenHeight, //
                         String pClosedImageURL, int pClosedWidth, int pClosedHeight, //
                         String pLeafImageURL, int pLeafWidth, int pLeafHeight, //
                         boolean pUseLeafImage )
    {
        this( new Tree( new TreeImageAdaptor( pOpenImageURL, pOpenWidth, pOpenHeight, pClosedImageURL, pClosedWidth, pClosedHeight, pLeafImageURL, pLeafWidth, pLeafHeight ), pUseLeafImage ) );
    }

    public static SizeableTree withFolders()
    {
        return new SizeableTree( FOLDER_OPEN_URL, 16, 16,//
                                 FOLDER_CLOSED_URL, 16, 16, //
                                 FOLDER_LEAF_URL, 16, 16, //
                                 false );
    }

    public SizeableTree style( String pStyleName )
    {
        mTree.addStyleName( pStyleName );
        return this;
    }

    public boolean isEmpty()
    {
        return (0 == mTree.getItemCount());
    }

    /**
     * Get the Currently Selected TreeNode
     *
     * @return Selected Node or null if none Selected
     */
    public TreeNode getSelectedNode()
    {
        return (TreeNode) mTree.getSelectedItem();
    }

    /**
     * Get the Currently Selected UserObject
     *
     * @return UserObject for the currently selected "row"
     */
    public Object getSelected()
    {
        TreeNode zNode = getSelectedNode();
        return (zNode != null) ? zNode.getUserObject() : null;
    }

    /**
     * Set the Selected Node & return the UserObject actually Selected
     *
     * @param pUserObject to select
     *
     * @return pUserObject or null if it was not found!
     */
    public Object setSelected( Object pUserObject )
    {
        MyTreeNode tn = getTreeNode( pUserObject );
        if ( tn != null )
        {
            tn.setSelected( true );
            return pUserObject;
        }
        mTree.setSelectedItem( null, true );
        return null;
    }

    /**
     * Check if the currently selected is Open.
     *
     * @return null if no current selected, otherwise the open state of the currently selected node
     */
    public Boolean isSelectedOpen()
    {
        TreeNode tn = getSelectedNode();
        return (tn == null) ? null : tn.areAnyOpen();
    }

    /**
     * Ensures that the specified item is visible, by adjusting the panel's scroll position.
     *
     * @param pUserObject the item whose visibility is to be ensured
     */
    public void ensureVisible( Object pUserObject )
    {
        MyTreeNode tn = getTreeNode( pUserObject );
        if ( tn != null )
        {
            mScrollPanel.ensureVisible( tn );
        }
    }

    public SizeableTree setAnimationEnabled( boolean pEnable )
    {
        mTree.setAnimationEnabled( pEnable );
        return this;
    }

    @Override
    public TreeNode addChild( Object pUserObject )
    {
        if ( pUserObject == null )
        {
            return null;
        }
        MyTreeNode tn = createMyTreeNode( pUserObject );
        mTree.addItem( tn );
        notifyOpenCloseChange( null );
        tn.addChildren();
        return tn;
    }

    @Override
    public boolean removeChild( Object pUserObject )
    {
        if ( pUserObject != null )
        {
            int zCount = mTree.getItemCount();
            for ( int i = 0; i < zCount; i++ )
            {
                TreeItem zItem = mTree.getItem( i );
                if ( pUserObject == zItem.getUserObject() )
                {
                    return removeWithSelectMangementAndNotification( zItem );
                }
            }
        }
        return false;
    }

    @Override
    public boolean removeDescendant( Object pUserObject )
    {
        MyTreeNode tn = getTreeNode( pUserObject );
        return (tn != null) && removeWithSelectMangementAndNotification( tn );
    }

    @Override
    public void clear()
    {
        mTree.removeItems();
        notifyOpenCloseChange( null );
    }

    @Override
    public boolean areAnyOpen()
    {
        int zChildCount = mTree.getItemCount(); // Top Level!
        for ( int i = 0; i < zChildCount; i++ )
        {
            TreeItem zItem = mTree.getItem( i ); // Top Level!
            if ( zItem.getChildCount() != 0 )
            {
                if ( zItem.getState() )
                {
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public boolean areAnyClosed()
    {
        int zChildCount = mTree.getItemCount(); // Top Level!
        for ( int i = 0; i < zChildCount; i++ )
        {
            TreeItem zItem = mTree.getItem( i ); // Top Level!
            if ( zItem.getChildCount() != 0 )
            {
                if ( ((TreeNode) zItem).areAnyClosed() )
                {
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public void openAll()
    {
        if ( childrenUpdateOpenClosedState( true ) )
        {
            notifyOpenCloseChange( true );
        }
    }

    @Override
    public void closeAll()
    {
        if ( childrenUpdateOpenClosedState( false ) )
        {
            notifyOpenCloseChange( false );
        }
    }

    /**
     * The Tree itself does NOT have a User Object
     *
     * @return null
     */
    @Override
    public Object getUserObject()
    {
        return null;
    }

    /**
     * @return iterator over Tree's UserObject(s) depth first
     */
    public Iterator<Object> iterator()
    {
        List<Object> collector = new ArrayList<Object>();
        int zCount = mTree.getItemCount(); // Top Level!
        for ( int i = 0; i < zCount; i++ )
        {
            MyTreeNode tn = (MyTreeNode) mTree.getItem( i );
            tn.addToDepthFirst( collector );
        }
        return collector.iterator();
    }

    public SizeableTree connectOpenCloseButtons( Button pOpenButton, Button pCloseButton )
    {
        if ( (pOpenButton != null) || (pCloseButton != null) )
        {
            final OpenCloseAllHelper zHelper = new OpenCloseAllHelper( pOpenButton, pCloseButton );
            addTreeSelectionListener( zHelper );
            addTreeOpenCloseListener( zHelper );
            if ( pOpenButton != null )
            {
                pOpenButton.addClickHandler( new ClickHandler()
                {
                    @Override
                    public void onClick( ClickEvent event )
                    {
                        zHelper.processOpenAllRequest();
                    }
                } );
            }
            if ( pCloseButton != null )
            {
                pCloseButton.addClickHandler( new ClickHandler()
                {
                    @Override
                    public void onClick( ClickEvent event )
                    {
                        zHelper.processCloseAllRequest();
                    }
                } );
            }
        }
        return this;
    }

    public void addTreeSelectionListener( TreeSelectionListener pListener )
    {
        if ( pListener != null )
        {
            if ( mSelectionListeners == null )
            {
                mSelectionListeners = new TreeSelectionListenerCollection();
            }
            mSelectionListeners.add( pListener );
        }
    }

    public void removeTreeSelectionListener( TreeSelectionListener pListener )
    {
        if ( pListener != null )
        {
            if ( mSelectionListeners != null )
            {
                mSelectionListeners.remove( pListener );
                if ( mSelectionListeners.isEmpty() )
                {
                    mSelectionListeners = null;
                }
            }
        }
    }

    protected TreeSelectionListenerCollection mSelectionListeners = null;

    protected void notifySelectionChange()
    {
        if ( mSelectionListeners != null )
        {
            mSelectionListeners.notify( getSelected() );
        }
    }

    public void addTreeOpenCloseListener( TreeOpenCloseListener pListener )
    {
        if ( pListener != null )
        {
            if ( mOpenCloseListeners == null )
            {
                mOpenCloseListeners = new TreeOpenCloseListenerCollection();
            }
            mOpenCloseListeners.add( pListener );
        }
    }

    public void removeTreeOpenCloseListener( TreeOpenCloseListener pListener )
    {
        if ( pListener != null )
        {
            if ( mOpenCloseListeners != null )
            {
                mOpenCloseListeners.remove( pListener );
                if ( mOpenCloseListeners.isEmpty() )
                {
                    mOpenCloseListeners = null;
                }
            }
        }
    }

    protected TreeOpenCloseListenerCollection mOpenCloseListeners = null;

    protected void notifyOpenCloseChange( Boolean pOpened )
    {
        if ( mOpenCloseListeners != null )
        {
            mOpenCloseListeners.openStateChanged( pOpened );
        }
    }

    private boolean childrenUpdateOpenClosedState( boolean pOpenAll )
    {
        boolean changed = false;
        int zChildCount = mTree.getItemCount(); // Top Level!
        if ( pOpenAll )
        {
            for ( int i = 0; i < zChildCount; i++ ) // Open from the Top Down
            {
                TreeItem zItem = mTree.getItem( i ); // Top Level!
                if ( zItem.getParentItem() == null )
                {
                    changed |= updateOpenClosedStateRecursively( zItem, pOpenAll );
                }
            }
        }
        else
        {
            for ( int i = zChildCount; 0 <= --i; ) // Close from the Bottom Up
            {
                TreeItem zItem = mTree.getItem( i ); // Top Level!
                if ( zItem.getParentItem() == null )
                {
                    changed |= updateOpenClosedStateRecursively( zItem, pOpenAll );
                }
            }
        }
        return changed;
    }

    private static boolean updateOpenClosedState( TreeItem pTreeItem, boolean pOpen )
    {
        if ( (pTreeItem.getState() != pOpen) && (pTreeItem.getChildCount() != 0) )
        {
            pTreeItem.setState( pOpen );
            return true;
        }
        return false;
    }

    private static boolean updateOpenClosedStateRecursively( TreeItem pTreeItem, boolean pOpenAll )
    {
        boolean changed = false;
        int zChildCount = pTreeItem.getChildCount();
        if ( pOpenAll )
        {
            changed = updateOpenClosedState( pTreeItem, pOpenAll ); // Open from the Top Down
            for ( int i = 0; i < zChildCount; i++ )
            {
                changed |= updateOpenClosedStateRecursively( pTreeItem.getChild( i ), pOpenAll );
            }
        }
        else
        {
            for ( int i = zChildCount; 0 <= --i; ) // Close from the Bottom Up
            {
                changed |= updateOpenClosedStateRecursively( pTreeItem.getChild( i ), pOpenAll );
            }
            changed |= updateOpenClosedState( pTreeItem, pOpenAll );
        }
        return changed;
    }

    private MyTreeNode getTreeNode( Object pUserObject )
    {
        if ( pUserObject != null )
        {
            int zCount = mTree.getItemCount(); // Top Level!
            for ( int i = 0; i < zCount; i++ )
            {
                MyTreeNode tn = (MyTreeNode) mTree.getItem( i ); // Top Level!
                if ( null != (tn = tn.getTreeNode( pUserObject )) )
                {
                    return tn;
                }
            }
        }
        return null;
    }

    private boolean removeWithSelectMangementAndNotification( TreeItem pTreeItem )
    {
        Object currentlySelected = getSelected();

        removeWithoutSelectMangementAndNotification( pTreeItem );

        restoreSelection( currentlySelected );
        return true;
    }

    private void restoreSelection( Object pPreviouslySelected )
    {
        Object restoredSelected = setSelected( pPreviouslySelected );
        if ( restoredSelected != pPreviouslySelected )
        {
            notifySelectionChange();
        }
        notifyOpenCloseChange( null );
    }

    private void removeWithoutSelectMangementAndNotification( TreeItem pTreeItem )
    {
        TreeItem zParentItem = pTreeItem.getParentItem();
        if ( zParentItem == null )
        {
            mTree.removeItem( pTreeItem );
        }
        else
        {
            zParentItem.removeItem( pTreeItem );
        }
    }

    private HierarchicalNode.ChangeListener<HierarchicalNode> getChangeListener()
    {
        if ( mChangeListener == null )
        {
            mChangeListener = new HierarchicalNode.ChangeListener<HierarchicalNode>()
            {
                @Override
                public void change( HierarchicalNode pNode, HierarchicalNode.Change pChange )
                {
                    if ( (pNode != null) && (pChange != null) )
                    {
                        if ( HierarchicalNode.Change.Deleted == pChange )
                        {
                            removeChild( pNode );
                        }
                        else
                        {
                            updateChildren( pNode );
                        }
                    }
                }
            };
        }
        return mChangeListener;
    }

    private HierarchicalNode.ChangeListener<HierarchicalNode> mChangeListener;

    private static class TreeImageAdaptor implements Tree.Resources
    {
        private ImageResource mOpen, mClosed, mLeaf;

        private TreeImageAdaptor( String pOpenImageURL, int pOpenWidth, int pOpenHeight, //
                                  String pClosedImageURL, int pClosedWidth, int pClosedHeight, //
                                  String pLeafImageURL, int pLeafWidth, int pLeafHeight )
        {
            mOpen = new ImageResourceAdapter( "Open", pOpenImageURL, pOpenWidth, pOpenHeight );
            mClosed = new ImageResourceAdapter( "Closed", pClosedImageURL, pClosedWidth, pClosedHeight );
            mLeaf = new ImageResourceAdapter( "Leaf", pLeafImageURL, pLeafWidth, pLeafHeight );
        }

        @Override
        public ImageResource treeOpen()
        {
            return mOpen;
        }

        @Override
        public ImageResource treeClosed()
        {
            return mClosed;
        }

        @Override
        public ImageResource treeLeaf()
        {
            return mLeaf;
        }
    }

    private MyTreeNode createMyTreeNode( Object pUserObject )
    {
        MyTreeNode tn;
        if ( pUserObject instanceof HasWidget )
        {
            tn = new MyTreeNode( ((HasWidget) pUserObject).getWidget(), pUserObject );
        }
        else if ( pUserObject instanceof Widget )
        {
            tn = new MyTreeNode( (Widget) pUserObject, pUserObject );
        }
        else
        {
            tn = new MyTreeNode( new Label( pUserObject.toString() ), pUserObject );
        }
        if ( pUserObject instanceof HierarchicalNode )
        {
            //noinspection unchecked
            ((HierarchicalNode) pUserObject).addChangeListener( getChangeListener() );
        }
        return tn;
    }

    private class MyTreeNode extends TreeItem implements TreeNode
    {
        private MyTreeNode( Widget pWidget, Object pUserObject )
        {
            super( pWidget );
            setUserObject( pUserObject );
        }

        public void addChildren()
        {
            Object zUserObject = getUserObject();
            if ( zUserObject instanceof HierarchicalNode )
            {
                addChildren( getChildren( (HierarchicalNode) zUserObject ) );
            }
        }

        @Override
        public MyTreeNode addChild( Object pUserObject )
        {
            if ( pUserObject == null )
            {
                return null;
            }
            MyTreeNode tn = createMyTreeNode( pUserObject );
            addItem( tn );
            tn.addChildren();
            notifyOpenCloseChange( null );
            return tn;
        }

        @Override
        public boolean removeChild( Object pUserObject )
        {
            if ( pUserObject != null )
            {
                int zCount = getChildCount();
                if ( zCount != 0 )
                {
                    for ( int i = 0; i < zCount; i++ )
                    {
                        TreeItem zItem = getChild( i );
                        if ( (zItem != null) && (pUserObject == zItem.getUserObject()) )
                        {
                            return removeWithSelectMangementAndNotification( zItem );
                        }
                    }
                }
            }
            return false;
        }

        @Override
        public boolean removeDescendant( Object pUserObject )
        {
            if ( pUserObject != null )
            {
                int zCount = getChildCount();
                if ( zCount != 0 )
                {
                    for ( int i = 0; i < zCount; i++ )
                    {
                        MyTreeNode tn = (MyTreeNode) getChild( i );
                        if ( pUserObject == tn.getUserObject() )
                        {
                            return removeWithSelectMangementAndNotification( tn );
                        }
                        if ( tn.removeDescendant( pUserObject ) )
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        @Override
        public void clear()
        {
            removeItems();
            notifyOpenCloseChange( null );
        }

        @Override
        public boolean areAnyOpen()
        {
            return parentsOpen() && (getChildCount() != 0) && getState();
        }

        @Override
        public boolean areAnyClosed()
        {
            return parentsOpen() && LLareAnyClosed();
        }

        @Override
        public void openAll()
        {
            if ( updateOpenClosedStateRecursively( this, true ) )
            {
                notifyOpenCloseChange( true );
            }
        }

        @Override
        public void closeAll()
        {
            if ( updateOpenClosedStateRecursively( this, false ) )
            {
                notifyOpenCloseChange( false );
            }
        }

        private boolean areAnyChildrenClosed()
        {
            for ( int i = getChildCount(); 0 <= --i; )
            {
                if ( ((MyTreeNode) getChild( i )).LLareAnyClosed() )
                {
                    return true;
                }
            }
            return false;
        }

        private boolean LLareAnyClosed()
        {
            return (getChildCount() != 0) && (!getState() || areAnyChildrenClosed());
        }

        private boolean parentsOpen()
        {
            MyTreeNode zParent = (MyTreeNode) getParentItem();
            return (zParent == null) || (zParent.getState() && zParent.parentsOpen());
        }

        private void addChildren( List<HierarchicalNode> pChildUserObjects )
        {
            if ( pChildUserObjects != null )
            {
                for ( HierarchicalNode zUserObject : pChildUserObjects )
                {
                    MyTreeNode tn = addChild( zUserObject );
                    if ( tn != null )
                    {
                        tn.addChildren();
                    }
                }
            }
        }

        public void addToDepthFirst( List<Object> pCollector )
        {
            pCollector.add( getUserObject() );
            int zCount = getChildCount();
            for ( int i = 0; i < zCount; i++ )
            {
                MyTreeNode tn = (MyTreeNode) getChild( i );
                tn.addToDepthFirst( pCollector );
            }
        }

        public MyTreeNode getTreeNode( Object pUserObject )
        {
            if ( pUserObject == getUserObject() )
            {
                return this;
            }
            int zCount = getChildCount();
            for ( int i = 0; i < zCount; i++ )
            {
                MyTreeNode tn = (MyTreeNode) getChild( i );
                if ( null != (tn = tn.getTreeNode( pUserObject )) )
                {
                    return tn;
                }
            }
            return null;
        }
    }

    @SuppressWarnings({"unchecked"})
    private static List<HierarchicalNode> getChildren( HierarchicalNode pUserObject )
    {
        return (List<HierarchicalNode>) pUserObject.getChildren();
    }

    protected void updateChildren( HierarchicalNode pNode )
    {
        MyTreeNode tn = getTreeNode( pNode );
        if ( tn != null )
        {
            List<HierarchicalNode> zChildren = getChildren( pNode );
            if ( Lists.isNullOrEmpty( zChildren ) )
            {
                Object currentlySelected = getSelected();

                tn.removeItems();

                restoreSelection( currentlySelected );
                return;
            }
            CurrentState cs = new CurrentState( tn );
            cs.dropChildrenAndAlignWith( zChildren, tn );
        }
    }

    private class CurrentState
    {
        private Object mUserObject;
        private boolean mSelected, mOpen;
        private List<CurrentState> mChildren = new ArrayList<CurrentState>();

        public CurrentState( MyTreeNode pTreeNode )
        {
            mUserObject = pTreeNode.getUserObject();
            mSelected = pTreeNode.isSelected();
            mOpen = pTreeNode.getState(); // Open
            int zChildCount = pTreeNode.getChildCount();
            for ( int i = 0; i < zChildCount; i++ )
            {
                mChildren.add( new CurrentState( (MyTreeNode) pTreeNode.getChild( i ) ) );
            }
        }

        public CurrentState( HierarchicalNode pNew )
        {
            mUserObject = pNew;
            mSelected = mOpen = false;
            List<HierarchicalNode> zChildren = getChildren( pNew );
            if ( zChildren != null )
            {
                for ( HierarchicalNode zChild : zChildren )
                {
                    mChildren.add( new CurrentState( zChild ) );
                }
            }
        }

        private void setStateOn( MyTreeNode pTreeNode )
        {
            pTreeNode.setState( mOpen );
            pTreeNode.setSelected( mSelected );
        }

        public Object getUserObject()
        {
            return mUserObject;
        }

        private boolean hasSameUserObject( CurrentState them )
        {
            return Objects.areEqual( this.getUserObject(), them.getUserObject() );
        }

        /**
         * Damages the mChildren state!
         *
         * @param pNewChildren -
         * @param pTreeNode    -
         */
        public void dropChildrenAndAlignWith( List<HierarchicalNode> pNewChildren, MyTreeNode pTreeNode )
        {
            List<CurrentState> zChildren = new ArrayList<CurrentState>( pNewChildren.size() );
            for ( HierarchicalNode zChild : pNewChildren )
            {
                zChildren.add( new CurrentState( zChild ) );
            }
            for ( CurrentState zChild : mChildren )
            {
                @SuppressWarnings({"SuspiciousMethodCalls"}) int at = pNewChildren.indexOf( zChild.getUserObject() );
                if ( at != -1 )
                {
                    zChildren.set( at, zChild );
                }
            }

            Object currentlySelected = getSelected();
            // Skip over the front of tree that is common && delete front of tree that is NOT in new Tree!
            int i = 0; // MyTreeNode Child Index
            while ( !zChildren.isEmpty() && !mChildren.isEmpty() && (i < pTreeNode.getChildCount()) )
            {
                //noinspection SuspiciousMethodCalls
                if ( !pNewChildren.contains( mChildren.get( 0 ).getUserObject() ) )
                {
                    mChildren.remove( 0 );
                    removeWithoutSelectMangementAndNotification( pTreeNode.getChild( i ) );
                    continue;
                }
                while ( mChildren.get( 0 ).hasSameUserObject( zChildren.get( 0 ) ) )
                {
                    zChildren.remove( 0 );
                    mChildren.remove( 0 );
                    i++;
                }
            }
            mChildren.clear();
            while ( i < pTreeNode.getChildCount() )
            {
                removeWithoutSelectMangementAndNotification( pTreeNode.getChild( i ) );
            }
            addTo( pTreeNode, zChildren );

            restoreSelection( currentlySelected );
        }

        private void addTo( MyTreeNode pTreeNode, List<CurrentState> zChildren )
        {
            if ( zChildren != null )
            {
                for ( CurrentState zChild : zChildren )
                {
                    MyTreeNode tn = createMyTreeNode( zChild.getUserObject() );
                    pTreeNode.addItem( tn );
                    zChild.setStateOn( tn );
                    addTo( tn, zChild.mChildren );
                }
            }
        }
    }

    private static class NoOpEnableable implements Enableable
    {
        public static Enableable deNull( Enableable pEnableable )
        {
            return (pEnableable != null) ? pEnableable : new NoOpEnableable();
        }

        @Override
        public boolean isEnabled()
        {
            return false;
        }

        @Override
        public void setEnabled( boolean pEnabled )
        {
        }
    }

    private class OpenCloseAllHelper implements TreeSelectionListener,
                                                TreeOpenCloseListener
    {
        private Enableable mOpenAll, mCloseAll;

        public OpenCloseAllHelper( Enableable pOpenAll, Enableable pCloseAll )
        {
            mOpenAll = NoOpEnableable.deNull( pOpenAll );
            mCloseAll = NoOpEnableable.deNull( pCloseAll );
            update();
        }

        private void setAllState( boolean pOpenAllEnabled, boolean pCloseAllEnabled )
        {
            mOpenAll.setEnabled( pOpenAllEnabled );
            mCloseAll.setEnabled( pCloseAllEnabled );
        }

        @Override
        public void openStateChanged( Boolean pOpened )
        {
            update();
        }

        @Override
        public void selected( Object pSelected )
        {
            update();
        }

        private void update()
        {
            setAllState( areAnyClosed(), areAnyOpen() );
        }

        public void processOpenAllRequest()
        {
            TreeNode tn = getSelectedNode();
            if ( (tn != null) && tn.areAnyClosed() )
            {
                tn.openAll();
                return;
            }
            openAll();
        }

        public void processCloseAllRequest()
        {
            TreeNode tn = getSelectedNode();
            if ( (tn != null) && tn.areAnyOpen() )
            {
                tn.closeAll();
                return;
            }
            closeAll();
        }
    }
}