/*

 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;

     }        

     */

 }