/*

 Wotonomy: OpenStep design patterns for pure Java applications.

 Copyright (C) 2000 Blacksmith, Inc.

 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.AWTEventMulticaster;

 import java.awt.BorderLayout;

 import java.awt.Component;

 import java.awt.Container;

 import java.awt.FlowLayout;

 import java.awt.Insets;

 import java.awt.event.ActionEvent;

 import java.awt.event.ActionListener;

 import java.awt.event.MouseEvent;

 import java.awt.event.MouseMotionListener;

 import java.beans.BeanInfo;

 import java.beans.Introspector;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.beans.PropertyDescriptor;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.util.Enumeration;

 import java.util.Vector;

 import javax.swing.AbstractButton;

 import javax.swing.Action;

 import javax.swing.JButton;

 import javax.swing.JFrame;

 import javax.swing.JPanel;

 import javax.swing.UIManager;

 /**

 * ButtonPanel handles display and event broadcasting of standard buttons like

 * OK/Cancel/Save/etc. The constructor takes a list or array of strings, each

 * representing a button to appear on the panel from left to right.

 * Any button click will send an action event to all listeners with the action

 * command containing the corresponding string.  Note action events are simply

 * forwarded from the buttons themselves, so the source of the event will be

 * the button, not the button panel.  The button panel is the source of the

 * STATE_CHANGED events that notify about changes to the panel itself.<BR><BR>

 *

 * @author michael@mpowers.net

 * @author $Author: cgruber $

 * @version $Revision: 904 $

 */

 public class ButtonPanel extends JPanel implements ActionListener, MouseMotionListener

 {

     // TODO: Button text should be read from resources.

 /**

 *   Specifies a "OK" button.

 *   This is also the action command sent by the OK button.

 */

     public static final String OK = "OK";

 /**

 *   Specifies a "Save" button.

 *   This is also the action command sent by the Save button.

 */

     public static final String SAVE = "Save";

 /**

 *   Specifies a "Refresh" button.

 *   This is also the action command sent by the Refresh button.

 */

     public static final String REFRESH = "Refresh";

 /**

 *   Specifies a "Clear All" button.

 *   This is also the action command sent by the Clear All button.

 */

     public static final String CLEAR_ALL = "Clear All";

 /**

 *   Specifies a "Refresh" button.

 *   This is also the action command sent by the Cancel button.

 */

     public static final String CANCEL = "Cancel";

 /**

 *   Specifies a "Yes" button.

 *   This is also the action command sent by the Yes button.

 */

     public static final String YES = "Yes";

 /**

 *   Specifies a "No" button.

 *   This is also the action command sent by the No button.

 */

     public static final String NO = "No";

 /**

 *   Specifies an "Add" button.

 *   This is also the action command sent by the Add button.

 */

     public static final String ADD = "Add";

 /**

 *   Specifies a "Remove" button.

 *   This is also the action command sent by the Remove button.

 */

     public static final String REMOVE = "Remove";

 /**

 *   This is the action command to all listeners when the button state is changed.

 */

     public static final String STATE_CHANGED = "STATE_CHANGED";

 /**

 *   This is the container to which buttons are added.

 */

     protected Container buttonContainer = null; // useful for subclasses

 /**

 *   This is the list of all buttons on the panel.

 */

     protected Vector buttonList = null;

 /**

 *   The insets for this panel, so they can be modified.

 */

     protected Insets insets = new Insets( 5, 5, 5, 5 );

 /**

 *   This is the layout manager - which must be a FlowLayout or subclass.

 */

     protected FlowLayout buttonPanelLayout = null;

     // for action multicasting

     protected ActionListener actionListener = null;

 /**

 * Constructs a ButtonPanel.  Three buttons are created

 * so the panel is filled when used in a GUI-builder environment.

 */

     public ButtonPanel()

     {

         buttonList = new Vector();

         initLayout();

         // default labels for bean layout

         setLabels( new String[] { "One", "Two", "Three" } );

     }

 /**

 * This method is responsible for the initial layout of the panel.

 * Subclasses can implement different layouts, but this method

 * is responsible for initializing buttonContainer and buttonPanelLayout

 * and setting the container to use the layout.

 */

     protected void initLayout()

     {

         this.setInsets( super.getInsets() );

         buttonContainer = this;

         buttonPanelLayout = new BetterFlowLayout( BetterFlowLayout.RIGHT );

         buttonContainer.setLayout(buttonPanelLayout);

         ((BetterFlowLayout)buttonPanelLayout).setWidthUniform( true );

         // setBackground( Color.blue ); // useful for debugging

     }

 /**

 * Constructs a ButtonPanel using specified buttons.

 * @param buttonList An array containing the strings to be used in labeling the buttons.

 */

     public ButtonPanel( String[] buttonList )

     {

         this();

         setLabels( buttonList );

     }

 /**

 * Constructs a ButtonPane using specified actions.  For each action, a button

 * is created, that when pressed the corresponding action is activated.  The

 * "name" of the action is used as the title of the button.

 * @param actionList An array of actions to be used to create buttons with.

 */

     public ButtonPanel( Action[] actionList )

     {

         this();

         setLabels( actionList );

     }

 /**

 * Creates the buttons to appear on the panel.  Any existing buttons

 * are replaced.  The labels are used as names and action commands

 * in addition to labels.

 * @param labels An array of strings to be used in labeling the buttons.

 * If null, all buttons will be removed.

 */

     public void setLabels( String[] labels )

     {

         if ( labels == null )

         {

             labels = new String[] {};

         }

         buttonContainer.removeAll();

         this.buttonList = new Vector( labels.length );

         String item = null;

         Component button;

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

         {

             item = labels[i];

             if ( item != null )

             {

                 button = createComponentWithLabel( item.toString() );

                 this.buttonList.addElement( item );

                 addComponentToPanel( button );

                 button.setEnabled( this.isEnabled() );

 /*

                 if ( i == 0 )

                 {

                     JRootPane root = SwingUtilities.getRootPane( button );

                     if ( root != null )

                         root.setDefaultButton( button );

                 }

 */

             }

             else

             {

                 throw new IllegalArgumentException( "ButtonPanel.setButtons: nulls are not allowed." );

             }

         }

         this.revalidate();

         this.repaint();

         broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED ) );

     }

 /**

 *

 */

     public void setLabels( Action[] actions )

     {

         if ( actions == null )

         {

             actions = new Action[] {};

         }

         buttonContainer.removeAll();

         this.buttonList = new Vector( actions.length );

         Action action = null;

         Component button;

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

         {

             action = actions[i];

             if ( action != null )

             {

                 String name = ( String )action.getValue( Action.NAME );

                 button = createComponentWithLabel( name );

                 this.buttonList.addElement( name );

                 addComponentToPanel( button );

                 button.setEnabled( this.isEnabled() ? action.isEnabled() : false );

                 // Add the action to the "button" if it knows about action listeners.

                 try

                 {

                     Method addActionListenerMethod =

                         button.getClass().getMethod( "addActionListener", new Class[] { ActionListener.class } );

                     addActionListenerMethod.invoke( button, new Object[] { action } );

                 }

                 catch ( NoSuchMethodException e ) { /* Do Nothing */ }

                 catch ( IllegalAccessException e ) { e.printStackTrace(); /* TODO: Do Something? */ }

                 catch ( InvocationTargetException e ) { e.printStackTrace(); /* TODO: Do Something? */ }

                 // Create a new listener for property change events and have

                 // the action broadcast to that listener.

                 PropertyChangeListener pcListener = new ActionChangeListener( button );

                 action.addPropertyChangeListener( pcListener );

             }

             else

             {

                 throw new IllegalArgumentException( "ButtonPanel.setButtons: nulls are not allowed." );

             }

         }

         this.revalidate();

         this.repaint();

         broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED ) );

     }

 /**

 * Gets the labels of the buttons that appear on the panel, ordered from left to right.

 * @return A new list containing strings used in labeling the buttons.

 */

     public String[] getLabels()

     {

         String[] labels = new String[ buttonList.size() ];

         int i = 0;

         for ( Enumeration it = buttonList.elements(); it.hasMoreElements(); )

         {

             labels[i++] = it.nextElement().toString();

         }

         return labels;

     }

 /**

 * Gets the first component having the specified name.

 * @return A component with the specified name, or null if none match.

 */

     public Component getButton( String aLabel )

     {

         if ( aLabel == null ) return null;

         Component c = null;

         int count = buttonContainer.getComponentCount();

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

         {

             c = buttonContainer.getComponent( i );

             if ( aLabel.equals( c.getName() ) )

             {

                 return c;

             }

         }

         return null;

     }

 /**

 * Creates a new component with the specified label.

 * The label is also used for the component's name

 * and action command, if any.

 * (This implementation returns a JButton.)

 * @param aLabel The label for the component that will be created.

 * @return The newly created component.

 */

     protected Component createComponentWithLabel( String aLabel )

     {

         String buttonLabel = aLabel; // TODO: get string from resource

         JButton newButton = new JButton(); // might allow other types in future

         newButton.setName( aLabel );

         newButton.setText( buttonLabel );

         newButton.setActionCommand( aLabel );

         newButton.addActionListener( this );

         return newButton;

     }

 /**

 * Adds a component to the right-most side of the layout.

 * @param aComponent The component to be added to the layout.

 */

     protected void addComponentToPanel( Component aComponent )

     {

         buttonContainer.add( aComponent );

     }

 /**

 * Changes the alignment of the buttons in the panel.  Defaults to right-justified.

 * @param alignment A valid alignment code, per BetterFlowLayout implementation.

 * @see BetterFlowLayout

 */

     public void setAlignment( int alignment )

     {

         buttonPanelLayout.setAlignment(alignment);

         buttonContainer.doLayout();

     }

 /**

 * Gets the alignment of the buttons in the panel.

 * @return An alignment code, per FlowLayout implementation.

 * @see FlowLayout

 */

     public int getAlignment()

     {

         return buttonPanelLayout.getAlignment();

     }

 /**

 * Changes the horizontal spacing between components in the panel.

 * @param newHgap the new spacing, in pixels.  May not be negative.

 */

     public void setHgap( int newHgap )

     {

         if ( newHgap < 0 ) return; // may not be negative

         buttonPanelLayout.setHgap( newHgap );

     }

 /**

 * Gets the current horizontal spacing between components.

 * @return the current horizontal spacing, in pixels.

 */

     public int getHgap()

     {

         return buttonPanelLayout.getHgap();

     }

 /**

 * Changes the vertical spacing between components in the panel.

 * @param newVgap the new spacing, in pixels.  May not be negative.

 */

     public void setVgap( int newVgap )

     {

         if ( newVgap < 0 ) return; // may not be negative

         buttonPanelLayout.setVgap( newVgap );

     }

 /**

 * Gets the current vertical spacing between components.

 * @return the current vertical spacing, in pixels.

 */

     public int getVgap()

     {

         return buttonPanelLayout.getVgap();

     }

 /**

 * Changes the insets for this panel.

 * @param newInsets the new insets.

 */

     public void setInsets( Insets newInsets )

     {

         insets = newInsets;

     }

 /**

 * Overridden to return the user-specified insets for this panel.

 * @return the current insets for this panel.

 */

     public Insets getInsets()

     {

         return insets;

     }

 /**

 * Overridden to call setEnabled on all components on panel.

 * @param isEnabled whether to enable the panel and all components on it.

 */

     public void setEnabled( boolean isEnabled )

     {

         super.setEnabled( isEnabled );

         int count = buttonContainer.getComponentCount();

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

         {

             buttonContainer.getComponent( i ).setEnabled( isEnabled );

         }

     }

     // Action Multicast methods

 /**

 * Adds an action listener to the list that will be

 * notified by button events and changes in button state.

 * @param l An action listener to be notified.

 */

      public void addActionListener(ActionListener l)

      {

            actionListener = AWTEventMulticaster.add(actionListener, l);

      }

 /**

 * Removes an action listener from the list that will be

 * notified by button events and changes in button state.

 * @param l An action listener to be removed.

 */

      public void removeActionListener(ActionListener l)

      {

            actionListener = AWTEventMulticaster.remove(actionListener, l);

      }

 /**

 * Notifies all registered action listeners of a pending Action Event.

 * @param e An action event to be broadcast.

 */

      protected void broadcastEvent(ActionEvent e)

      {

          if (actionListener != null)

          {

              actionListener.actionPerformed(e);

          }

      }

     // interface ActionListener

 /**

 * Called by buttons on panel and by other components that

 * might be set to broadcast events to this listener.

 * @param e An action event to be received.

 */

      public void actionPerformed(ActionEvent e)

      {

             broadcastEvent(e);

      }

 /**

 * A property change listener that listens specifically for property changes

 * from action objects.  This is the class that ties in the action to the

 * button.  This class is added to an action as a property change listener.

 * The corresponding component is referenced by this class toe easily handle

 * updates to the component caused by changes to the action.

 */

      public class ActionChangeListener implements PropertyChangeListener

      {

         /** The UI component that is affected by the action's changes. */

         Component theComponent;

         /**

         * Constructs an ActionChangeListener with the given component being

         * the recipient of the action's changes.

         * @param The component to bind with the action.

         */

         public ActionChangeListener( Component aComponent )

         {

             super();

             theComponent = aComponent;

         }

         /**

         * Called whenever a property changes on the action object.

         * @pram e The property change event generated by the action.

         */

         public void propertyChange( PropertyChangeEvent e )

         {

             String propertyName = e.getPropertyName();

             if ( propertyName.equals( Action.NAME ) )

             {

                 String name = ( String )e.getNewValue();

                 if ( theComponent instanceof AbstractButton )

                 {

                     AbstractButton button = ( AbstractButton )theComponent;

                     String oldName = button.getName();

                     button.setText( name );

                     button.setName( name );

                     button.setActionCommand( name );

                     // Replace the old name of the component with the new name

                     // in the ButtonPanel's list of components.

                     buttonList.setElementAt( name, buttonList.indexOf( oldName ) );

                 }

                 // TODO: If component is not a button (or doesn't define the getText()

                 // then what should be done.

             }

             else if ( propertyName.equals( "enabled" ) )

             {

                 Boolean enabled = ( Boolean )e.getNewValue();

                 theComponent.setEnabled( ButtonPanel.this.isEnabled() ? enabled.booleanValue() : false );

             }

             // TODO: Icon?

         }

      }

     // for testing

     public static void main( String[] argv )

     {

         try

         {

             UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );

         }

         catch (Exception exc)

         {

         }

         JFrame dialog = new JFrame();

         BorderLayout bl = new BorderLayout( 20, 20 );

         ButtonPanel panel = new ButtonPanel();

 //        ButtonPanel panel = new ButtonPanel( new String[] { "OkayOkay", "CancelCancel" } );

         dialog.getContentPane().setLayout( bl );

         dialog.getContentPane().add( panel, BorderLayout.CENTER );

         dialog.setLocation( 50, 50 );

         // dialog.setSize( 450, 150 );

         panel.setAlignment( BetterFlowLayout.CENTER_VERTICAL );

         panel.getButton( "One" ).setEnabled( false );

         dialog.pack();

         dialog.setVisible( true );

         try

         {

             BeanInfo info = Introspector.getBeanInfo( ButtonPanel.class );

             PropertyDescriptor[] props = info.getPropertyDescriptors();

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

             {

                 System.out.println( props[i].getName() );

             }

         }

         catch (Exception exc)

         {

             System.out.println( exc );

         }

     }

     public void mouseDragged(MouseEvent e)

     {

     }

     public void mouseMoved(MouseEvent e)

     {

     }

 }