/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.customizer;
  
  import com.cosylab.gui.components.introspection.BeanPropertiesTableModel;
  import com.cosylab.gui.components.introspection.DefaultPropertiesTable;
  
  import com.cosylab.util.Debug;
  import com.cosylab.util.ObjectList;
  
  import java.awt.Color;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  
  import javax.swing.JComponent;
  import javax.swing.border.LineBorder;
  import javax.swing.table.TableModel;
  
  
  /**
   * Default implementation of the <code>Editor</code> interface. Supports
   * editing of aspects via a simple property table,  multiple aspects, and
   * custom editors for selected aspects.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   */
  public class DefaultEditor implements Editor
  {
  	private DefaultPropertiesTable defaultPropertiesTable = null;
  	private HashMap<String, ArrayList<Editor>> customEditors = null;
  	private HashMap<String, BeanPropertiesTableModel> defaultPropertiesTableModels = null;
  	private Object displayer = null;
  	private ObjectList activeEditors = null;
  
  	/**
  	 * Cunstructs an empty editor.
  	 */
  	public DefaultEditor()
  	{
  		super();
  		defaultPropertiesTableModels = new HashMap<String, BeanPropertiesTableModel>();
  		customEditors = new HashMap<String, ArrayList<Editor>>();
  		activeEditors = new ObjectList(Editor.class);
  		defaultPropertiesTable = new DefaultPropertiesTable();
  		defaultPropertiesTable.setBorder(new LineBorder(Color.BLACK));
  	}
  
  	/**
  	 * <p>
  	 * Should return names of properties of a dispalyer to be edited within the
  	 * sepcified aspect through generic proeprty tables. This empty
  	 * implementation however returns null.
  	 * </p>
  	 * 
  	 * <p>
  	 * Subclasses should override this method to return arrays of
  	 * <code>String</code> names of properties to be edited via property
  	 * tables in the specified aspect.
  	 * </p>
  	 * 
  	 * <p>
  	 * The Strings returned should specify names of qualified <i>JavaBean</i>
  	 * properties with conventional getter and setter methods.
  	 * </p>
  	 * 
  	 * <p>
  	 * If a custom editor has been specified for the aspect the result of theis
  	 * method is ignored as the custom editor is used for editing the aspect
  	 * instead of generic property table.
  	 * </p>
  	 *
  	 * @param aspect the aspect of the displayer to be edited with generic
  	 *        proeprty table
  	 *
  	 * @return array of names of properties to be edited with the proeprty
  	 *         table in the specified aspect
  	 */
  	public String[] getDefaultProperties(String aspect)
 	{
 		Debug.out(aspect);
 
 		return null;
 	}
 
 	/**
 	 * Returns the editor component for the selected aspect and displayer. If a
 	 * custom editor exists for the selected aspect, it is returned. Otherwise
 	 * a property table is returned containing the selected proeprties of the
 	 * aspect as returned by <code>#getDefaultProperties(String)</code>
 	 * method.
 	 *
 	 * @param displayer the component for which the editor should be returned
 	 * @param aspect the specific editing aspect for which the editor should be
 	 *        returned
 	 *
 	 * @return the editor component for the selected aspect and displayer.
 	 *
 	 * @throws IllegalArgumentException if no custom editor is found for the
 	 *         aspect and  getDefaultProperties(String) returns null for the
 	 *         aspect.
 	 *
 	 * @see com.cosylab.gui.components.customizer.Editor#getEditorComponent(Object,
 	 *      String)
 	 */
 	public JComponent getEditorComponent(Object displayer, String aspect)
 		throws IllegalArgumentException
 	{
 		Editor ed;
 		Iterator it = activeEditors.iterator();
 
 		while (it.hasNext()) {
 			if ((ed = (Editor)it.next()).canEdit(displayer, aspect)) {
 				return ed.getEditorComponent(displayer, aspect);
 			}
 		}
 
 		ArrayList l = customEditors.get(aspect);
 
 		if (l != null) {
 			it = l.iterator();
 
 			while (it.hasNext()) {
 				if ((ed = (Editor)it.next()).canEdit(displayer, aspect)) {
 					activeEditors.add(ed);
 
 					return ed.getEditorComponent(displayer, aspect);
 				}
 			}
 		}
 
 		initializeDefaultPropertiesTable(displayer, aspect);
 
 		return defaultPropertiesTable;
 	}
 
 	/**
 	 * Overrides the current editor for the specified aspect with the editor
 	 * specified. This method can be used to replace generic property tables
 	 * as editors for the  aspect specified.
 	 *
 	 * @param aspect for which to use the editor specified
 	 * @param editor the editor to replace the current editor of the aspect
 	 *        specified
 	 */
 	public void addCustomEditor(String aspect, Editor editor)
 	{
 		ArrayList<Editor> l = customEditors.get(aspect);
 
 		if (l == null) {
 			l = new ArrayList<Editor>();
 			customEditors.put(aspect, l);
 		}
 
 		l.add(editor);
 	}
 
 	/**
 	 * Applies all the changes done to the custom editors as well as the
 	 * property tables.
 	 *
 	 * @see com.cosylab.gui.components.customizer.Editor#applySettings()
 	 */
 	public void applySettings()
 	{
 		applyTableProperties();
 
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].applySettings();
 		}
 	}
 
 	/**
 	 * Inspecting the <code>ASPECTS</code> and all the custom editors, this
 	 * method determines, wether the specified aspect of the dispalyer can be
 	 * edited by this editor.
 	 *
 	 * @param displayer Object to be edited (is ignored and can be
 	 *        <code>null</code>)
 	 * @param aspect String name of aspect to be edited.
 	 *
 	 * @return <code>true</code> if the specifed aspect of the displayer can be
 	 *         edited, <code>false</code> otherwise.
 	 *
 	 * @see com.cosylab.gui.components.customizer.Editor#canEdit(Object,
 	 *      String)
 	 */
 	public boolean canEdit(Object displayer, String aspect)
 	{
 		ArrayList<Editor> l = customEditors.get(aspect);
 
 		if (l != null) {
 			Iterator<Editor> it = l.iterator();
 
 			while (it.hasNext()) {
 				if (it.next().canEdit(displayer, aspect)) {
 					return true;
 				}
 			}
 		}
 
 		return (Arrays.binarySearch(ASPECTS, aspect) >= 0
 		&& getDefaultProperties(aspect) != null);
 	}
 
 	/**
 	 * Reverts all the changes done to the custom editors as well as the
 	 * property tables.
 	 *
 	 * @see com.cosylab.gui.components.customizer.Editor#revertSettings()
 	 */
 	public void revertSettings()
 	{
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].revertSettings();
 		}
 	}
 
 	/**
 	 * Stops editing with all custom editors as well as property tables.
 	 *
 	 * @see com.cosylab.gui.components.customizer.Editor#stopEditing()
 	 */
 	public void stopEditing()
 	{
 		defaultPropertiesTableModels.clear();
 
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].stopEditing();
 		}
 
 		activeEditors.clear();
 	}
 
 	/*
 	 * Applies the changes done to the property tables.
 	 */
 	protected void applyTableProperties()
 	{
 		if (displayer == null) {
 			return;
 		}
 
 		Object[] modelList = defaultPropertiesTableModels.values().toArray();
 		//Class c = displayer.getClass();
 
 		for (int i = 0; i < modelList.length; i++) {
 			BeanPropertiesTableModel model = (BeanPropertiesTableModel)modelList[i];
 
 			try {
 				model.applyProperties();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/*
 	 * Initializes the proeprty table for the selected displayer and aspect.
 	 */
 	protected void initializeDefaultPropertiesTable(Object displayer,
 	    String aspect) throws IllegalArgumentException
 	{
 		this.displayer = displayer;
 
 		if (defaultPropertiesTableModels.containsKey(aspect)) {
 			defaultPropertiesTable.setModel((TableModel)defaultPropertiesTableModels
 			    .get(aspect));
 		} else {
 			String[] names = getDefaultProperties(aspect);
 
 			if (names != null) {
 				BeanPropertiesTableModel model = new BeanPropertiesTableModel(displayer,
 					    names);
 				defaultPropertiesTableModels.put(aspect, model);
 				defaultPropertiesTable.setModel(model);
 			}
 		}
 	}
 
 	/*
 	 * Returns all the custom editors that have been supplied.
 	 */
 	private Editor[] getActiveEditors()
 	{
 		return (Editor[])activeEditors.toArray();
 	}
 }
 
 /* __oOo__ */