/*

 Wotonomy: OpenStep design patterns for pure Java applications.

 Copyright (C) 2000 Intersect Software Corporation

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, see http://www.gnu.org

 */

 package net.wotonomy.ui.swing.components;

 import java.awt.BorderLayout;

 import java.awt.Component;

 import java.awt.Cursor;

 import java.awt.Dimension;

 import java.awt.GridBagConstraints;

 import java.awt.GridBagLayout;

 import java.awt.event.ActionEvent;

 import java.awt.event.ActionListener;

 import java.awt.event.MouseAdapter;

 import java.awt.event.MouseEvent;

 import java.util.Enumeration;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Stack;

 import java.util.Vector;

 import javax.swing.ComboBoxModel;

 import javax.swing.JButton;

 import javax.swing.JComboBox;

 import javax.swing.JComponent;

 import javax.swing.JList;

 import javax.swing.JPanel;

 import javax.swing.JScrollPane;

 import javax.swing.JToolBar;

 import javax.swing.JTree;

 import javax.swing.ListCellRenderer;

 import javax.swing.ListSelectionModel;

 import javax.swing.UIManager;

 import javax.swing.event.ListDataEvent;

 import javax.swing.event.ListDataListener;

 import javax.swing.event.ListSelectionEvent;

 import javax.swing.event.ListSelectionListener;

 import javax.swing.event.TreeModelEvent;

 import javax.swing.event.TreeModelListener;

 import javax.swing.event.TreeSelectionEvent;

 import javax.swing.event.TreeSelectionListener;

 import javax.swing.tree.DefaultMutableTreeNode;

 import javax.swing.tree.DefaultTreeCellRenderer;

 import javax.swing.tree.DefaultTreeModel;

 import javax.swing.tree.DefaultTreeSelectionModel;

 import javax.swing.tree.TreeCellRenderer;

 import javax.swing.tree.TreeModel;

 import javax.swing.tree.TreePath;

 import javax.swing.tree.TreeSelectionModel;

 import net.wotonomy.foundation.internal.WotonomyException;

 /**

 * TreeChooser is a FileChooser-like panel that

 * uses a TreeModel as a data source.  It basically

 * provides an alternative to JTree for rendering 

 * and manipulating tree-like data.

 *

 * @author michael@mpowers.net

 * @author $Author: cgruber $

 * @version $Revision: 904 $

 */

 public class TreeChooser extends JPanel 

     implements ActionListener, ListSelectionListener, 

         TreeSelectionListener, TreeModelListener, ListCellRenderer

 {   

     /**

     * The TreeChooser responds to this action command

     * by calling displayPrevious().

     */

         public static final String BACK = "Back";

     /**

     * The TreeChooser responds to this action command

     * by calling displayHome().

     */

         public static final String HOME = "Home";

     /**

     * The TreeChooser responds to this action command

     * by calling displayParent().

     */

         public static final String UP = "Up";

     /**

     * The TreeChooser responds to this action command

     * by attempting to navigate to the first node in

     * the current selection and display that node's children.

     */

         public static final String SELECT = "Select";

         protected JList contents;

         protected JComboBox pathCombo; 

         protected JToolBar toolBar;

         protected TreeModel model;

         protected TreeSelectionModel selectionModel;

     protected TreeCellRenderer renderer;

     protected TreePath displayPath;

     protected Stack pathStack;

     protected int pathIndent;        

     private ChooserComboBoxModel comboBoxModel;

     private JTree bogusJTree; // needed for tree cell renderer

     private Dimension preferredSize;

     public TreeChooser()

     {

         preferredSize = new Dimension( 300, 200 );

         model = new DefaultTreeModel( new DefaultMutableTreeNode( "Root" ) );

         displayPath = new TreePath( model.getRoot() );

         selectionModel = new DefaultTreeSelectionModel();

         renderer = new DefaultTreeCellRenderer();

         pathStack = new Stack();

         pathIndent = 0; // 16;

         comboBoxModel = new ChooserComboBoxModel( this );

         bogusJTree = new JTree();

         bogusJTree.setModel( model );

                 init();

         displayHome();

         stopListening(); // clear existing listeners

         startListening();

         }

     public Dimension getPreferredSize()

     {

         return preferredSize;

     }

         protected void init()

         {

                 this.setLayout( new BorderLayout( 10, 10 ) );        

                 contents = initList();

         contents.getSelectionModel().setSelectionMode( 

                 ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );

                 // synchs with DefaultTreeSelectionModel

                 JScrollPane scrollPane = new JScrollPane( contents );

                 scrollPane.setPreferredSize( new Dimension( 200, 150 ) );

                 this.add( scrollPane, BorderLayout.CENTER );

         Component previewPane = initPreviewPane();

         if ( previewPane != null )

         {

             this.add( previewPane, BorderLayout.EAST );

         }

                 JPanel navigationPanel = new JPanel();

                 navigationPanel.setLayout( new BorderLayout( 10, 10 ) );

                 this.add( navigationPanel, BorderLayout.NORTH );

                 pathCombo = initComboBox();

         if ( pathCombo != null )

         {

             pathCombo.setModel( comboBoxModel );

                         // put combo in a grid bag to handle varying

                         //  heights of JToolBars across platforms

                         JPanel panel = new JPanel();

                         panel.setLayout( new GridBagLayout() );

                         GridBagConstraints gbc = new GridBagConstraints();

                         gbc.fill = GridBagConstraints.HORIZONTAL;

                         gbc.weightx = 1.0;

                         panel.add( pathCombo, gbc );

             navigationPanel.add( panel, BorderLayout.CENTER );

         }

                 Component toolBar = initToolBar();

         if ( toolBar != null )

         {

             navigationPanel.add( toolBar, BorderLayout.EAST );

         }

         }

     /**

     * Creates tool bar or return null if no tool bar is desired.

     * This implementation returns a JToolBar containing buttons

     * for BACK, UP, and HOME.

     */ 

     protected Component initToolBar()

     {

                 JToolBar toolBar = new JToolBar();

                 toolBar.setFloatable( false );

         JButton button;

                 button = new JButton( UIManager.getIcon("FileChooser.upFolderIcon") );

         button.setActionCommand( UP );

         button.addActionListener( this );

         toolBar.add( button );

                 button = new JButton( UIManager.getIcon("FileChooser.homeFolderIcon") );

         button.setActionCommand( HOME );

         button.addActionListener( this );

         toolBar.add( button );

 /*        

                 button = new JButton( UIManager.getIcon("FileChooser.newFolderIcon") );

         button.setActionCommand( BACK );

         button.addActionListener( this );

         toolBar.add( button );

 */        

         return toolBar;

     }

     /**

     * Creates the component that is used to display a preview of the

     * selected item(s) in the content area.  This component would listen

     * to the selection model to update itself when the selected items change.

     * Return null to omit this component.

     * This implementation returns null.

     */ 

     protected Component initPreviewPane()

     {

         return null;

     }

     /**

     * Creates the JComboBox that is used to render the path leading to

     * the displayed contents.  Return null to omit this combo box.

     * This implementation returns a stock JComboBox that uses this

     * class as its cell renderer.

     */ 

     protected JComboBox initComboBox()

     {

         JComboBox comboBox = new JComboBox();

         comboBox.setRenderer( this );

         return comboBox;

     }

     /**

     * Creates the JList that is used to render the path leading to

     * the displayed contents.  This method may not return null.

     * This implementation returns a stock JList that uses this

     * class as its cell renderer and fires a SELECT action event

     * on double click.

     */ 

     protected JList initList()

     {

         JList list = new JList();

         list.setCellRenderer( this );

         list.addMouseListener( new MouseAdapter() 

         {

             public void mouseClicked( MouseEvent evt )

             {

                 if ( evt.getClickCount() > 1 )

                 {   

                     actionPerformed( new ActionEvent( this, 0, SELECT ) );

                 }

             }

         });

         return list;

     }

     /**

     * Begins listening to the specified tree model 

     * and tree selection model.

     */

     protected void startListening()

     {

         model.addTreeModelListener( this );

         selectionModel.addTreeSelectionListener( this );

         contents.addListSelectionListener( this );

     }

     /**

     * Stops listening to the specified tree model 

     * and tree selection model.

     */

     protected void stopListening()

     {

         model.removeTreeModelListener( this );

         selectionModel.removeTreeSelectionListener( this );

         contents.removeListSelectionListener( this );

     }

     /**

     * Returns the TreeModel used by the TreeChooser.

     */ 

     public TreeModel getModel()

     {

         return model;

     }

     /**

     * Sets the TreeModel used by the TreeChooser.

     */ 

     public void setModel( TreeModel aTreeModel )

     {

         stopListening();

         model = aTreeModel;

         bogusJTree.setModel( aTreeModel );

         pathStack.removeAllElements();

         startListening();

         displayHome();

     }

     /**

     * Returns the TreeSelectionModel used by the TreeChooser.

     */ 

     public TreeSelectionModel getSelectionModel()

     {

         return selectionModel;

     }

     /**

     * Sets the TreeSelectionModel used by the TreeChooser.

     */ 

     public void setSelectionModel( TreeSelectionModel aSelectionModel )

     {

         selectionModel = aSelectionModel;

         if ( aSelectionModel.getSelectionMode() == 

             TreeSelectionModel.SINGLE_TREE_SELECTION )

         {

             contents.getSelectionModel().setSelectionMode( 

                 ListSelectionModel.SINGLE_SELECTION );

         }

         else

         {

             contents.getSelectionModel().setSelectionMode( 

                 ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );

         }

         updateSelection();

     }

     /**

     * Returns the TreeCellRenderer used by the TreeChooser.

     */ 

     public TreeCellRenderer getRenderer()

     {

         return renderer;

     }

     /**

     * Sets the TreeCellRenderer used by the TreeChooser.

     */ 

     public void setRenderer( TreeCellRenderer aRenderer )

     {

         renderer = aRenderer;

         updateContents();

     }

     /**

     * Displays the "home" directory.

     * This implementation displays the root node's children.

     */

     public void displayHome()

     {

         setDisplayPath( null );        

     }

     /**

     * Displays the parent path of the currently displayed path.

     */

     public void displayParent()

     {

         setDisplayPath( displayPath.getParentPath() );    

     }

     /**

     * Displays the last displayed path before the current one,

     * emulating the behavior of a "back" button.

     */

     public void displayPrevious()

     {

         if ( pathStack.empty() )

         {

             displayHome();   

         }

         else

         {

             setDisplayPathDirect( (TreePath) pathStack.pop() );

             updateContents();

         }

     }

     /**

     * Pushes the previous item onto the stack, sets

     * the display path, and then updates the contents.

     * If aPath is null, the root node's children are displayed.

     */

     public void setDisplayPath( TreePath aPath )

     {

         if ( aPath == null )

         {

             aPath = new TreePath( getModel().getRoot() );

         }

         if ( ! displayPath.equals ( aPath ) )

         {

             pathStack.push( displayPath );

             setDisplayPathDirect( aPath );

         }

         updateContents();

     }

     /**

     * Sets the displayPath field and does not

     * update the stack nor update the contents.

     */

     protected void setDisplayPathDirect( TreePath aPath )

     {

         displayPath = aPath;   

     }

     /**

     * Gets the currently displayed path.

     */

     public TreePath getDisplayPath()

     {

         return displayPath;   

     }

     /**

     * Called when selected path changes or when model indicates

     * that the displayed path has changed.

     */

     protected void updateContents()

     {

         stopListening();

         // update combo box        

         comboBoxModel.fireContentsChanged();

         // update list contents

         Object displayedObject = displayPath.getLastPathComponent();

 /*

 //FIXME: this display group doesn't seem to be getting the sort orderings from parent        

 if ( displayedObject instanceof net.wotonomy.ui.EODisplayGroup )        

 System.out.println( ((net.wotonomy.ui.EODisplayGroup)displayedObject).displayedObjects() );            

 */

         int count = model.getChildCount( displayedObject );

         Object[] children = new Object[ count ];

         for ( int i = 0; i < count; i++ )

         {

             children[i] = model.getChild( displayedObject, i );

         }

         contents.setListData( children );

         startListening();

         // synchronize the selection        

         updateSelection();

     }

     /**

     * Updates the selection in the list to reflect the

     * selection in the tree selection model.

     */

     public void updateSelection()

     {

         int index;

         Object last = displayPath.getLastPathComponent();

         TreePath[] selectionPaths = selectionModel.getSelectionPaths();

         if ( selectionPaths != null )

         {

             List selectedIndices = new LinkedList();

             for ( int i = 0; i < selectionPaths.length; i++ )

             {

                 if ( displayPath.equals( selectionPaths[i].getParentPath() ) )

                 {

                     index = getModel().getIndexOfChild( 

                         last, selectionPaths[i].getLastPathComponent() );

                     if ( index != -1 ) 

                     {

                         selectedIndices.add( new Integer( index ) );

                     }

                     else // should never happen

                     {

                         throw new WotonomyException( 

                             "Could not find child of displayed node." );

                     }

                 }

             }

             int[] selected = new int[ selectedIndices.size() ];

             for ( int i = 0; i < selected.length; i++ )

             {

                 selected[i] = ((Integer)selectedIndices.get(i)).intValue();   

             }

             stopListening();

             contents.setSelectedIndices( selected );

             startListening();

         }

     }

     // interface TreeModelListener

     public void treeNodesChanged( TreeModelEvent evt )

     { 

 /*            

         if ( displayPath.getLastPathComponent().toString().equals( 

             evt.getTreePath().getLastPathComponent().toString() ) )

         {

 System.out.println( "TreeChooser.treeNodesChanged: " + count++ );  

 */

             updateContents();

 /*            

         }

         else

         {

             System.out.println( evt.getTreePath() + " != " + displayPath );

         }

 */        

     }

     public void treeNodesInserted( TreeModelEvent evt )

     { 

 //            updateContents();

     }

     public void treeNodesRemoved( TreeModelEvent evt )

     { 

 //            updateContents();

     }

     public void treeStructureChanged( TreeModelEvent evt )

     {  

         if ( ( evt.getTreePath().equals( displayPath ) )

         || ( evt.getTreePath().isDescendant( displayPath ) ) )

         {

 //            setDisplayPath( evt.getTreePath() );

         }

         displayHome();

     }

     // interface TreeSelectionListener

     /**

     * Called when the tree selection model's value changes.

     * This is presumably an external change, so this calls

     * updateSelection.

     */

     public void valueChanged( TreeSelectionEvent evt )

     {

         updateSelection();   

     }

     // interface ListSelectionListener

     /**

     * Called when user changes the selection in the list.

     * This implementation updates the tree selection model

     * with the corresponding selection.

     */

     public void valueChanged( ListSelectionEvent evt )

     {

         if ( ! evt.getValueIsAdjusting() )

         {

             Object last = displayPath.getLastPathComponent();

             int[] selection = contents.getSelectedIndices();

             TreePath[] selectionPaths = new TreePath[ selection.length ];

             for ( int i = 0; i < selection.length; i++ )

             {

                 selectionPaths[i] = displayPath.pathByAddingChild(

                     getModel().getChild( last, selection[i] ) );

             }

             selectionModel.setSelectionPaths( selectionPaths );

         }

     }

     // interface ListCellRenderer

     /**

     * This method returns the component returned by the tree cell renderer.

     */

     public Component getListCellRendererComponent(

         JList list,

         Object value,

         int index,

         boolean isSelected,

         boolean cellHasFocus )

     {

         boolean isLeaf = ( model.isLeaf( value ) );

         bogusJTree.setForeground( list.getForeground() );

         bogusJTree.setBackground( list.getBackground() );

         JComponent result = (JComponent) renderer.getTreeCellRendererComponent(

             bogusJTree, value, isSelected, (list != contents), 

                 isLeaf, index, cellHasFocus );

 /*

         if ( ( list != contents ) && ( index > -1 ) )

         {

             result.setBorder( 

                 BorderFactory.createEmptyBorder( 0, index*pathIndent, 0, 0 ) );

         }

         else

         {

             result.setBorder( 

                 BorderFactory.createEmptyBorder() );

         }

 */        

         return result;

     }

     // interface ActionListener

     public void actionPerformed( ActionEvent evt )

     {

         String command = evt.getActionCommand();

         if ( HOME.equals( command ) )

         {

             displayHome();

         }

         else

         if ( UP.equals( command ) )

         {

             displayParent();

         }

         else

         if ( BACK.equals( command ) )

         {

             displayPrevious();

         }

         else

         if ( SELECT.equals( command ) )

         {

             Cursor oldCursor = getCursor();

             setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );

             int index = contents.getSelectedIndex();

             // if selection 

             if ( index != -1 )

             {

                 Object parent = displayPath.getLastPathComponent();

                 Object child = getModel().getChild( parent, index );

                 // if selected item is not a leaf

                 if ( getModel().getChildCount( child ) > 0 )

                 {

                     // navigate to selected item

                     setDisplayPath( displayPath.pathByAddingChild( child ) );

                 }

             }

             setCursor( oldCursor );

         }

     }

     private class ChooserComboBoxModel implements ComboBoxModel

     {

         TreeChooser treeChooser;

         Vector listeners;

         ChooserComboBoxModel( TreeChooser aTreeChooser )

         {

             treeChooser = aTreeChooser; 

             listeners = new Vector();

         }

         public int getSize()

         {

             return treeChooser.displayPath.getPathCount(); 

         }

         public Object getElementAt(int index)

         {

             return treeChooser.displayPath.getPathComponent( index );    

         }

         public Object getSelectedItem()

         {

             return treeChooser.displayPath.getLastPathComponent();

         }

         public void setSelectedItem(Object anItem)

         {

             if ( ! ( 

                 treeChooser.displayPath.getLastPathComponent().equals( anItem ) ) )

             {

                 Object[] items = treeChooser.displayPath.getPath();

                 TreePath path = new TreePath( getModel().getRoot() );

                 for ( int i = 1; i < items.length; i++ )

                 {

                     if ( path.getLastPathComponent() == anItem )

                     {

                         treeChooser.setDisplayPath( path );

                         return;

                     }

                     path = path.pathByAddingChild( items[i] );

                 }

             }

         }

         public void addListDataListener(ListDataListener l) 

         {

             listeners.add( l );

         }

         public void removeListDataListener(ListDataListener l) 

         {

             listeners.remove( l );

         }

         public void fireContentsChanged()

         {

             Enumeration e = listeners.elements();

             while ( e.hasMoreElements() )

             {

                 ((ListDataListener)e.nextElement()).contentsChanged( 

                     new ListDataEvent( 

                     this, ListDataEvent.CONTENTS_CHANGED, 0, getSize() ) );

             }

         }   

     }

 }