/*
   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.Color;
  import java.awt.Component;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.Point;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.util.Enumeration;
  import java.util.EventObject;
  import java.util.Vector;
  
  import javax.swing.Icon;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JList;
  import javax.swing.JPanel;
  import javax.swing.JTable;
  import javax.swing.JTree;
  import javax.swing.ListCellRenderer;
  import javax.swing.SwingUtilities;
  import javax.swing.UIManager;
  import javax.swing.border.Border;
  import javax.swing.border.EmptyBorder;
  import javax.swing.border.LineBorder;
  import javax.swing.event.CellEditorListener;
  import javax.swing.event.ChangeEvent;
  import javax.swing.table.TableCellEditor;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.tree.TreeCellEditor;
  import javax.swing.tree.TreeCellRenderer;
  
  /***
  * A cell renderer that displays icons in addition to text,
  * and additionally is an editor in case you want to click
  * the icon to trigger some kind of action.  
  * You probably should override both getStringForContext and
  * getIconForContext to achieve your desired results. 
  * To receive mouse clicks, set the same instance of the
  * renderer as the editor for the same component.<br><br>
  *
  * One notable addition is that this class is an action event
  * broadcaster.  ActionEvents are broadcast when the mouse is
  * clicked on the button with an action event containing a 
  * user-configurable string that defaults to CLICKED. <br><br>
  *
  * The renderer itself can be used as a JComponent if
  * you need something like a JLabel that allows you to click
  * on the icon.  You will want to call setIcon and setText
  * to configure the component since the renderer method would
  * not be called.  (If you add an instance of the renderer
  * to a container, you cannnot use the same instance as an
  * editor in a table, tree, or list.)
  *
  * @author michael@mpowers.net
  * @version $Revision: 904 $
  * $Date: 2006-02-18 23:19:05 +0000 (Sat, 18 Feb 2006) $
  */
  public class IconCellRenderer extends JPanel
  	implements TableCellRenderer, TableCellEditor, 
          TreeCellRenderer, TreeCellEditor, ListCellRenderer,
          Runnable, ActionListener, MouseListener 
  {	
  	public static final String CLICKED = "CLICKED";
  	
  	/***
  	* The panel that is re-used to render everything.
  	* This is returned by getRendererForContext.
  	*/
      protected JPanel rendererPanel;
  	protected JLabel rendererLabel;
      protected JButton rendererButton;
  
  	/***
  	* The panel that is used to receive mouse clicks.
  	* It must be a different component from rendererPanel.
 	* This is returned by getEditorForContext.
 	*/
     protected JPanel editorPanel;
 	protected JLabel editorLabel;
     protected JButton editorButton;
 	
 	private Object lastKnownValue;
     private JComponent lastKnownComponent;
 		
 	// do as DefaultTableCellRenderer does
 	private Border noFocusBorder;
 	private Border treeFocusBorder;
 	private Color unselectedForeground;
 	private Color unselectedBackground;
 	
 	private Vector actionListeners;
 	private String actionCommand;
 	private Vector cellEditorListeners;
     
     private boolean editable;
     private boolean clickable;
     				
     /***
     * Default constructor.
     */
     public IconCellRenderer()
     {                                                
         editable = true;
         clickable = true;
         
         noFocusBorder = new EmptyBorder(1, 1, 1, 1);
         treeFocusBorder = new LineBorder( 
             UIManager.getColor("Tree.selectionBorderColor") );
 		setActionCommand( CLICKED );
 
         rendererPanel = new JPanel();
         rendererPanel.setLayout( new GridBagLayout() );
 
         editorPanel = this;
         editorPanel.setLayout( new GridBagLayout() );
                         
         // set up constraints
         GridBagConstraints imageConstraints = new GridBagConstraints();
         imageConstraints.gridx = 0;
         GridBagConstraints labelConstraints = new GridBagConstraints();
         labelConstraints.fill = GridBagConstraints.HORIZONTAL;
         labelConstraints.gridx = 1;
         labelConstraints.weightx = 1.0;
         labelConstraints.ipadx = 1;
         labelConstraints.insets = new Insets( 0, 1, 0, 0 ); // sweat the pixel
 
         // make the editor panel go away when not in use
         // and pass through all mouse events to container        
         
         //this is not very useful since editorLabel and editorButton
         //get all of the events        
         editorPanel.addMouseListener( this );
         
 		rendererLabel = new JLabel();
 		rendererLabel.setOpaque( false );
         rendererPanel.add( rendererLabel, labelConstraints );
 
 		editorLabel = new JLabel();
         editorLabel.setText( "" ); // default state
 		editorLabel.setOpaque( false );
         editorPanel.add( editorLabel, labelConstraints );
 
 		unselectedForeground = rendererLabel.getForeground();
 		unselectedBackground = rendererLabel.getBackground();
         
         rendererButton = new JButton();
         rendererButton.setBorder( null );
         rendererButton.setBorderPainted( false );
         rendererButton.setContentAreaFilled( false );
         rendererButton.setFocusPainted( false );
         rendererButton.setMargin( new Insets( 0, 0, 0, 0 ) );
         rendererPanel.add( rendererButton, imageConstraints );
         
         editorButton = new JButton();
         editorButton.setEnabled( clickable ); // default state
         editorButton.setIcon( null ); // default state
         editorButton.setBorder( null );
         editorButton.setBorderPainted( false );                                            
         editorButton.setContentAreaFilled( false );
         editorButton.setFocusPainted( false );
         editorButton.setMargin( new Insets( 0, 0, 0, 0 ) );        
         editorPanel.add( editorButton, imageConstraints );
 
         editorButton.addActionListener( this );      
 
         //add these in order to dispatch the MouseEvents
         //to the lastKnownComponent, and proper management of
         //DnD operations
         editorLabel.addMouseListener( this );    
         editorButton.addMouseListener( this );                    
     }
     
 /***
 * Returns the text string currently displayed in the editor component.
 */    
     public String getText() 
     {
         return editorLabel.getText();
     }
     
 /***
 * Sets the text string displayed in the editor component.
 * Default is an empty string.
 */
     public void setText( String aString )
     {
         editorLabel.setText( aString );
     }
 
 /***
 * Returns the icon currently displayed in the editor component.
 */    
     public Icon getIcon() 
     {
         return editorButton.getIcon();
     }
     
 /***
 * Sets the icon currently displayed in the editor component.
 * Default is null.
 */
     public void setIcon( Icon anIcon )
     {
         editorButton.setIcon( anIcon );
         if ( !isClickable() )
         {
             editorButton.setDisabledIcon( anIcon );
         }
     }
 
 /***
 * Returns whether the editor component's label text is editable.
 */    
     public boolean isEditable() 
     {
         return editable;
     }
     
 /***
 * Sets whether the editor component's label text is editable.
 * Default is true.  Editable text is not yet implemented.
 */
     public void setEditable( boolean isEditable )
     {
         editable = isEditable;
     }
 
 /***
 * Returns whether the editor component's icon is clickable.
 */    
     public boolean isClickable() 
     {
         return clickable;
     }
     
 /***
 * Sets whether the editor component's icon is clickable.
 * Default is true.
 */
     public void setClickable( boolean isClickable )
     {
         clickable = isClickable;
         editorButton.setEnabled( clickable );
     }
 
 /***
 * Returns the component from getRendererForContext.
 */    
     public Component getListCellRendererComponent(JList list,
                                               Object value,
                                               int index,
                                               boolean isSelected,
                                               boolean cellHasFocus)
     {
         lastKnownComponent = list;
         return getRendererForContext(
             list, value, index, 0, isSelected, cellHasFocus, false, true );
     }
 
 /***
 * Returns the component from getRendererForContext.
 */
     public Component getTableCellRendererComponent(JTable table, Object value,
                      boolean isSelected, boolean hasFocus, int row, int column)
     {
         lastKnownComponent = table;
 		return getRendererForContext( 
 			table, value, row, column, isSelected, hasFocus, false, true );
     }
 
 /***
 * Returns the component from getRendererForContext.
 */
     public Component getTreeCellRendererComponent(JTree tree,
                                               Object value,
                                               boolean selected,
                                               boolean expanded,
                                               boolean leaf,
                                               int row,
                                               boolean hasFocus)
     {                
         lastKnownComponent = tree;
 		return getRendererForContext( 
 			tree, value, row, 0, selected, hasFocus, expanded, leaf );
     }
 	
 /***
 * Returns getEditorForContext with the same parameters with hasFocus true.
 */
 	public Component getTableCellEditorComponent(JTable table,
 		Object value, boolean isSelected, int row, int column)
 	{
 		lastKnownValue = value;
         lastKnownComponent = table;
 		return getEditorForContext( 
 			table, value, row, column, isSelected, true, false, true );
 	}
 
 /***
 * Returns the component from getEditorForContext with hasFocus true.
 */
     public Component getTreeCellEditorComponent(JTree tree,
                                                 Object value,
                                                 boolean isSelected,
                                                 boolean expanded,
                                                 boolean leaf,
                                                 int row)
     {
 
         
         lastKnownValue = value;
         lastKnownComponent = tree;
 		
 		return getEditorForContext( 
 			tree, value, row, 0, isSelected, true, expanded, leaf );
     }                                                
                                                 
 /***
 * This default implementation returns a JPanel that is configured by
 * calling configureComponentForContext.  
 * @return An component that is used to render content.
 */
     public Component getRendererForContext(
         JComponent container, Object value,
         int row, int column,
         boolean isSelected, boolean hasFocus, 
         boolean isExpanded, boolean isLeaf )
     {
 
 		
 		configureComponentForContext( rendererPanel, rendererButton, rendererLabel, 
             container, value, row, column,
 			isSelected, hasFocus, isExpanded, isLeaf );
 		return rendererPanel;
     }
 
 /***
 * This method returns a separate component that should be visually
 * identical to the renderer component.  We can't simply reuse the
 * renderer component because the renderer is still used to paint
 * the table while the editor component is displayed. Clicks are 
 * received on this component.
 * This default implementation returns a JPanel that is configured by
 * calling configureComponentForContext.  
 * @return A component used to receive clicks on the cell.
 */
     public Component getEditorForContext(
         JComponent container, Object value,
         int row, int column,
         boolean isSelected, boolean hasFocus, 
         boolean isExpanded, boolean isLeaf )
     {
 		configureComponentForContext( editorPanel, editorButton, editorLabel, 
             container, value, row, column,
 			true, hasFocus, isExpanded, isLeaf ); // editor should always be selected
 
 		return editorPanel;
     }
 
 /***
 * Called to configure components
 */ 
 	protected void configureComponentForContext(
         JPanel component, JButton iconButton, JLabel label, 
         JComponent container, Object value, 
         int row, int column,
         boolean isSelected, boolean hasFocus, 
         boolean isExpanded, boolean isLeaf )
 	{
         if (hasFocus) 
         {
             if ( container instanceof JTable )
             {
                 component.setBorder( 
                     UIManager.getBorder("Table.focusCellHighlightBorder") );
             }
             else
             {
                 component.setBorder( noFocusBorder );   
             }
 
             if ( container instanceof JTree ) // was: (false)
             {   
                 label.setBorder( treeFocusBorder );
             }
             else
             {
                 label.setBorder( noFocusBorder );
             }
         } 
         else 
         {
             label.setBorder(noFocusBorder);
             component.setBorder(noFocusBorder);
         }
         
         if (isSelected) 
         {
             if ( container instanceof JTree )
             {
                 label.setOpaque( true );
                 label.setForeground(UIManager.getColor("Tree.selectionForeground"));
                 label.setBackground(UIManager.getColor("Tree.selectionBackground"));
                 component.setBackground(container.getBackground());
             }
             else if ( container instanceof JTable )
             {
                 label.setOpaque( false );
                 label.setForeground( ((JTable)container).getSelectionForeground() );
                 component.setBackground(((JTable)container).getSelectionBackground());
             }
             else
             {
                 label.setOpaque( false );
                 label.setForeground(UIManager.getColor("Table.selectionForeground"));
                 component.setBackground(UIManager.getColor("Table.selectionBackground"));
             }
         }
         else 
         {
             label.setOpaque( false );
             label.setForeground(container.getForeground());
             component.setBackground(container.getBackground());
         }
 
         label.setFont(container.getFont());
 
         Icon icon = getIconForContext( 
 			container, value, row, column, isSelected, hasFocus, isExpanded, isLeaf );
         iconButton.setIcon( icon );
         if ( !isClickable() )
         {
             iconButton.setDisabledIcon( icon );
         }
 
         String text = getStringForContext( 
 			container, value, row, column, isSelected, hasFocus, isExpanded, isLeaf );
             
 		if ( ( text == null ) || ( "".equals( text ) ) )
 		{
             if ( ! label.getText().equals( "" ) )
     			label.setText( "" );
 		}
 		else
 		{
             if ( ! label.getText().equals( text ) )
     			label.setText( text );
 		}
 	}
 	
 /***
 * Override this method to provide an icon for the renderer.
 * This default implementation returns null.
 * @return An icon to be displayed in the cell, or null to omit the
 * icon from the cell.
 */
     public Icon getIconForContext(
         JComponent container, Object value,
         int row, int column,
         boolean isSelected, boolean hasFocus, 
         boolean isExpanded, boolean isLeaf )
     {
         return null;
     }
 
 /***
 * Override this method to provide a string for the renderer.
 * This default implementation returns toString on the value parameter,
 * or null if the value is null.
 * @return A string to be displayed in the cell.
 */
     public String getStringForContext(
         JComponent container, Object value,
         int row, int column,
         boolean isSelected, boolean hasFocus, 
         boolean isExpanded, boolean isLeaf )
     {
 		if ( value == null ) return null;
         return value.toString();
     }
 	
 	/***
 	* Adds the specified listener to the list of listeners
 	* to be notified when the button receives a click.
 	*/
 	public void addActionListener( ActionListener aListener )
 	{
 		if ( actionListeners == null ) 
 		{
 			actionListeners = new Vector( 2 );	
 		}
 		actionListeners.add( aListener );
 	}
 	
 	/***
 	* Removes the specified listener from the list of listeners
 	* to be notified when the button receives a click.
 	*/
 	public void removeActionListener( ActionListener aListener )
 	{
 		actionListeners.remove( aListener );
 	}
 	
 	/***
 	* Broadcasts the specified action event to all listeners.
 	*/
 	protected void fireActionEvent( ActionEvent anActionEvent )
 	{
 		if ( actionListeners == null ) return;
 		// vector's enumeration is not fail-fast
 		Enumeration e = actionListeners.elements();
 		while ( e.hasMoreElements() )
 		{
 			((ActionListener)e.nextElement()).actionPerformed( anActionEvent );
 		}
 	}
 	
 	/***
 	* Returns the action command broadcast when this icon
     * receives a click.  Defaults to CLICKED.
 	*/
 	public String getActionCommand()
 	{
 		return actionCommand;
 	}
 
 	/***
 	* Sets the action command broadcast when this table
 	* receives a double click.
 	*/	
 	public void setActionCommand( String anActionCommand )
 	{
 		actionCommand = anActionCommand;	
 	}
 	
 // interface CellEditor
 
 	/***
 	* Returns lastKnownValue, although this should not be called.
 	*/
 	public Object getCellEditorValue()
 	{
 		return lastKnownValue;
 	}
 	
 	/***
 	* Returns true.
 	*/
 	public boolean isCellEditable(EventObject anEvent)
 	{
         return true;
 	}
 	
 	/***
 	* Returns true.
 	*/
 	public boolean shouldSelectCell(EventObject anEvent)
 	{
 		return true;
 	}
 	
 	/***
 	* Fires an editing stopped event and returns true.
 	*/
 	public boolean stopCellEditing()
 	{
 		ChangeEvent event = new ChangeEvent( this );
 		if ( cellEditorListeners != null )
 		{
 			// vector's enumeration is not fail-fast
 			Enumeration e = cellEditorListeners.elements();
 			while ( e.hasMoreElements() )
 			{
                 // broadcast editing cancelled since no value is edited
 				((CellEditorListener)e.nextElement()).editingCanceled( event );
 			}
 		}
         lastKnownComponent = null;		
 		return true;
 	}
 	
 	/***
 	* Fires an editing cancelled event and returns true.
 	*/
 	public void cancelCellEditing()
 	{                
 		//HACK: cancelCellEditing() causes for the dragGesture
 		//to be NOT recognized AT ALL since on the next MOUSE_PRESSED
 		//the cell editor first needs to startEditing() [if in the tree
 		//the CellEditorListener is a BasicTreeUI class] 
 		//(before the drag gesture event can be recognized).        
         //Also the lastKnownComponent should not be set to null, 
         //none of the mouse events won't dispathced to the lastKnownComponent
         //in that case.		
 		
 		//Not calling it at all does seem to fix it, but what are the
 		//consequences???
 		//Trying to workaround this might solve it, but it introduces having
 		//an extra listener (a MouseMotionListnener), which might be wasteful
 		//(i.e. only if a Mouse_dragged event has been initiated, but DragGesture
 		//hasn't been recognized, postpone calling this till finish the DnD event)
 		//But what if do DnD and not exited ??? The mouseExited() is not called
 		//anyway until the DnD event is done.				
 				        
 		ChangeEvent event = new ChangeEvent( this );
 		if ( cellEditorListeners == null ) return;
 		// vector's enumeration is not fail-fast
 		Enumeration e = cellEditorListeners.elements();
 		
 		while ( e.hasMoreElements() )
 		{            
 			((CellEditorListener)e.nextElement()).editingCanceled( event );
 		}                
         
         //DO not nullify this 
         lastKnownComponent = null;                       
 	}
 	
 	/***
 	* Adds the specified listener to the list of listeners
 	* to be notified when the table receives a double click.
 	*/
 	public void addCellEditorListener( CellEditorListener aListener )
 	{		
 		if ( cellEditorListeners == null ) 
 		{
 			cellEditorListeners = new Vector( 2 );	
 		}
 		cellEditorListeners.add( aListener );	
 	}
 	
 	/***
 	* Removes the specified listener from the list of listeners
 	* to be notified when the table receives a double click.
 	*/
 	public void removeCellEditorListener( CellEditorListener aListener )
 	{
 		cellEditorListeners.remove( aListener );
 	}
     
 // interface ActionListener
     
     /***
     * Puts ourself on the end of the event queue for 
     * firing our action event to all listeners.
     */
     public void actionPerformed( ActionEvent evt )
     {        
         //commented out in order NOT to set lastKnownComponent to null, since
         //if this object is inside a table or tree, relying on getCellEditorValue() 
         //to return the currently edited object
         //cancelCellEditing();        
         
         SwingUtilities.invokeLater( this );
     }
 	
 // interface Runnable
 	
 	/***
 	* Fires the action event to all listeners.  
 	* This is triggered by a click on the icon.
 	*/
 	public void run()
 	{
 		fireActionEvent( new ActionEvent( this, 0, getActionCommand() ) );	
 	}
 
 // interface MouseListener 
     
     /***
     * Passes through editor mouse clicks to last known component.
     * (left click only)
     */
 	public void mouseClicked(MouseEvent e)
     {                        
         if(lastKnownComponent != null){
             Object source = e.getSource();            
             if(source != null)
             {
                 if(source == editorPanel)
                 {
                     lastKnownComponent.dispatchEvent(                 
                             SwingUtilities.convertMouseEvent(                    
                                 editorPanel, e, lastKnownComponent ) );                     
 
                 }                
                 else if(source == editorLabel)
                 {
                     lastKnownComponent.dispatchEvent(                 
                         SwingUtilities.convertMouseEvent(                    
                             editorLabel, e, lastKnownComponent ) );         
                 }           
 
                 else if(source == editorButton)
                 {
                     lastKnownComponent.dispatchEvent(                 
                         SwingUtilities.convertMouseEvent(                    
                             editorButton, e, lastKnownComponent ) );         
                 }           
             }                
         }                
     }
 
     /***
     * Passes through editor right-mouse (popup trigger) mouse events to last known component.
     * Needed for possible displaying of popup menus on right click 
     */
     public void mousePressed(MouseEvent e)
     {                
         if ( e.isPopupTrigger() )
         {
             if(lastKnownComponent != null)
             {
                 Object source = e.getSource();            
                 if(source != null)
                 {
                     if(source == editorPanel)
                     {                     
                         lastKnownComponent.dispatchEvent(                 
                                 SwingUtilities.convertMouseEvent(                    
                                     editorPanel, e, lastKnownComponent ) );                     
                     }
                     else if(source == editorLabel)
                     {
                         lastKnownComponent.dispatchEvent(                 
                             SwingUtilities.convertMouseEvent(                    
                                 editorLabel, e, lastKnownComponent ) );         
                     }           
     
                     else if(source == editorButton)
                     {   
                         lastKnownComponent.dispatchEvent(                 
                             SwingUtilities.convertMouseEvent(                    
                                 editorButton, e, lastKnownComponent ) );         
                     }           
                 }                
             }
         }                
     }
 
     /***
     * Does nothing.
     */
     public void mouseReleased(MouseEvent e)
     {                      
         if ( e.isPopupTrigger() )
         {
             if(lastKnownComponent != null){        
     
                 Object source = e.getSource();            
                 if(source != null)
                 {
                     if(source == editorPanel) 
                     {                    
                         lastKnownComponent.dispatchEvent(                 
                                 SwingUtilities.convertMouseEvent(                    
                                     editorPanel, e, lastKnownComponent ) );                     
                     }            
         
                     else if(source == editorLabel) 
                     {
                         lastKnownComponent.dispatchEvent(                 
                             SwingUtilities.convertMouseEvent(                    
                                 editorLabel, e, lastKnownComponent ) );         
                     }           
     
                     else if(source == editorButton) 
                     {
                         lastKnownComponent.dispatchEvent(                 
                             SwingUtilities.convertMouseEvent(                    
                                 editorButton, e, lastKnownComponent ) );         
                     }           
                 }                
             }
         }                
     }
 
     /***
     * Does nothing.
     */
     public void mouseEntered(MouseEvent e)
     {
     }
     
     /***
     * Cancels cell editing.
     */
     public void mouseExited(MouseEvent e)
     {        
         Object source = e.getSource();
         if(source != null && source instanceof JComponent){
             //need to convert the Point from the source's coordinate system to editorPanel's coordinate system.
             //(note that simple editorPanel.contains(e.getPoint()) fails if source is editorButton)
             
             Point convertedPoint = SwingUtilities.convertPoint((JComponent) source, e.getPoint(), editorPanel); 
             
             //check if exited from editorButton, but still inside the editorPanel (works for editorLabel as well)            
             if(!editorPanel.contains(convertedPoint)){
 
                 //This was getting called before, but it interfers with the DnD operation
                 cancelCellEditing();
             }
         }      
     }
     
     /* This might be redundant    
     public void cleanUp(){
         
         //since cancelCellEditing() was never called call it now                
         cancelCellEditing();
         stopCellEditing();
         
         editorButton.removeActionListener( this );      
         editorPanel.removeMouseListener( this ); 
         editorLabel.removeMouseListener( this );    
         editorButton.removeMouseListener( this );                            
         lastKnownComponent = null;
         lastKnownValue = null;
     }        
     */
 }