/*
    * $Id: FieldManager.java,v 1.12 2006/10/25 10:07:42 edankert Exp $
    *
    * The contents of this file are subject to the Mozilla Public License 
    * Version 1.1 (the "License"); you may not use this file except in 
    * compliance with the License. You may obtain a copy of the License at 
    * http://www.mozilla.org/MPL/ 
    *
    * Software distributed under the License is distributed on an "AS IS" basis, 
   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
   * for the specific language governing rights and limitations under the License.
   *
   * The Original Code is XML Hammer code. (org.xmlhammer.*)
   *
   * The Initial Developer of the Original Code is Edwin Dankert. Portions created 
   * by the Initial Developer are Copyright (C) 2005 - 2006 the Initial Developer. 
   * All Rights Reserved.
   *
   * Contributor(s): Edwin Dankert <edankert@gmail.com>
   */
  
  package org.xmlhammer.gui;
  
  import java.awt.Component;
  import java.awt.event.FocusEvent;
  import java.awt.event.FocusListener;
  import java.awt.event.ItemEvent;
  import java.awt.event.ItemListener;
  import java.util.ArrayList;
  
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JTextField;
  import javax.swing.JToggleButton;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  import javax.swing.event.DocumentEvent;
  import javax.swing.event.DocumentListener;
  import javax.swing.event.EventListenerList;
  
  import org.apache.log4j.Logger;
  
  /***
   * Manages the fields for a project, handling undo and focus ...
   * 
   * @version $Revision: 1.12 $, $Date: 2006/10/25 10:07:42 $
   * @author Edwin Dankert <edankert@gmail.com>
   */
  
  public class FieldManager implements FocusListener, ItemListener, DocumentListener {
      protected EventListenerList listeners = new EventListenerList();
  
      private ArrayList<JComponent> fields = null;
  	private ProjectView view = null;
  	private JComponent lastFocusedComponent = null;
      private boolean fieldsChanged = false;
      private boolean propertiesChanged = false;
      private boolean ignore = false;
  
  	/***
  	 * @param view the view this field manager should manage.
  	 */
  	public FieldManager( ProjectView view) {
  		fields = new ArrayList<JComponent>();
  		this.view = view;
  	}
  	
  	/***
  	 * @param field the field to listen to changes on.
  	 */
  	public void addField( JComponent field) {
  		fields.add( field);
  		
  		if ( field instanceof JToggleButton) {
  			((JToggleButton)field).addItemListener( this);
              field.addFocusListener( this);
  		} else if ( field instanceof JComboBox) {
              if ( ((JComboBox)field).isEditable()) {
      			Component editor = ((JComboBox)field).getEditor().getEditorComponent();
      			
      			if ( editor instanceof JTextField) {
      				fields.add( (JTextField)editor);
      				((JTextField)editor).getDocument().addDocumentListener(this);
      				((JTextField)editor).addFocusListener( this);
      			}
              } else {
                  field.addFocusListener( this);
                  ((JComboBox)field).addItemListener( this);
              }
  		} else if ( field instanceof JTextField) {
  			((JTextField)field).getDocument().addDocumentListener( this);
              field.addFocusListener( this);
  		}
  	}
  	
  	/***
  	 * @param field the field to listen to changes for.
  	 */
  	public void removeField( JComponent field) {
 		fields.remove( field);
 		field.removeFocusListener( this);
 
 		if ( field instanceof JToggleButton) {
 			((JToggleButton)field).removeItemListener( this);
 		} else if ( field instanceof JComboBox) {
 			Component editor = ((JComboBox)field).getEditor().getEditorComponent();
 			if ( editor instanceof JTextField) {
 				((JTextField)editor).getDocument().removeDocumentListener( this);
 				((JTextField)editor).removeFocusListener( this);
 			}
 			((JComboBox)field).removeItemListener( this);
 		} else if ( field instanceof JTextField) {
 			((JTextField)field).getDocument().removeDocumentListener( this);
 		}
 	}
 	
 	/***
 	 * @param event invoked when a field gained focus.
 	 */
 	public void focusGained( FocusEvent event) {
 		lastFocusedComponent = (JComponent)event.getSource();
 		view.setSelected( true);
 	}
 
 	/***
 	 * @param event invoked when a field lost focus.
 	 */
 	public void focusLost( FocusEvent event) {}
 	
 	/***
 	 * @return the field which had focus last.
 	 */
 	public JComponent getLastFocusedField() {
 		return lastFocusedComponent;
 	}
 	
 	/***
 	 * @return true when any of the fields have been changed by the user.
 	 */
 	public boolean isChanged() {
 		return fieldsChanged || propertiesChanged;
 	}
 	
 	/***
 	 * @param changed overrides the changed state from the outside (view saved/initialised).
 	 */
 	public void setChanged( boolean changed) {
 		setPropertiesChanged(changed);
         setFieldsChanged(changed);
 
         notifyChange();
 	}
 	
     /***
      * @param changed overrides the changed state from the outside.
      */
     public void setFieldsChanged( boolean changed) {
         this.fieldsChanged = changed;
 
         notifyChange();
     }
 
     /***
      * @param changed overrides the changed state from the outside.
      */
     public void setPropertiesChanged( boolean changed) {
         this.propertiesChanged = changed;
 
         notifyChange();
     }
 
 	/***
 	 * @param e state has changed.
 	 */
 	public void itemStateChanged( ItemEvent e) {
         if (!ignore) {
             fieldsChanged = true;
     		notifyChange(); 
         }
 	}
 	
     /***
      * @param e state has changed.
      */
     public void setIgnoreChanges( boolean ignore) {
         this.ignore = ignore;
     }
 
     /***
      * @param e state has changed.
      */
     public boolean isIgnoreChanges() {
         return ignore;
     }
 
     /***
 	 * notifies user changes to the underlying project view.
 	 *
 	 */
 	public void notifyChange() {
    		view.setChanged( isChanged());
 
         Object[] list = listeners.getListenerList();
         
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for ( int i = list.length-2; i >= 0; i -= 2) {
             if ( list[i] == ChangeListener.class) {
                 ((ChangeListener)list[i+1]).stateChanged( new ChangeEvent( this));
             }
         }
 	}
 
     public void insertUpdate(DocumentEvent event) {
         Logger.getLogger(this.getClass()).debug("insertUpdate( "+event+")");
         
         if (!ignore) {
             for (JComponent component : fields) {
                 if (component instanceof JTextField) {
                     JTextField field = (JTextField)component;
                     if (field.getDocument() == event.getDocument() && field.hasFocus()) {
                         fieldsChanged = true;
                         notifyChange();
                         break;
                     }
                 }
             }
         }
     }
 
     public void removeUpdate(DocumentEvent event) {
         Logger.getLogger(this.getClass()).debug("removeUpdate( "+event+")");
 
         if (!ignore) {
             for (JComponent component : fields) {
                 if (component instanceof JTextField) {
                     JTextField field = (JTextField)component;
                     if (field.getDocument() == event.getDocument() && field.hasFocus()) {
                         fieldsChanged = true;
                         notifyChange();
                         break;
                     }
                 }
             }
         }
     }
 
     public void addChangeListener(ChangeListener l) {
         listeners.add(ChangeListener.class, l);
     }
 
     public void removeChangeListener(ChangeListener l) {
         listeners.remove(ChangeListener.class, l);
     }
 
     public void changedUpdate(DocumentEvent arg0) {}
 }