/*
    * 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;
  
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.ComponentListener;
  import java.beans.Beans;
  
  import javax.swing.AbstractAction;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.TransferHandler;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyTransferHandler;
  import com.cosylab.gui.components.util.CosyUIElements;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.ScreenCapturer;
  
  
  /**
   * A container for simple displayers is able to display a small dispalyer
   * component  together with an optional title in a vertical or horizontal
   * resizable layout. It also supports
   * <code>com.cosylab.gui.components.util.PopupManager</code> and
   * <code>com.cosylab.gui.components.customizer.Customizer</code>.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   */
  public abstract class AbstractDisplayerPanel extends JPanel
  	implements PopupManageable, StateOriginator 
  {
  	private static final long serialVersionUID = 1L;
  
  	/** Lays out the components horizontaly. */
  	public static final int HORIZONTAL_LAYOUT = 0;
  
  	/** Lays out componetns vertically */
  	public static final int VERTICAL_LAYOUT = 1;
  
  	
  	/**
  	 * Lays out components either horizontally or vertically according to the
  	 * space available
  	 */
  	public static final int DYNAMIC_LAYOUT = 2;
  	private ComponentListener resizeListener;
  	private AbstractCustomizerPanel customizer;
  	private PopupManager popupManager;
  	private boolean popupEnabled;
  	private ResizableTextLabel titleLabel;
  	private String title;
  	private boolean enhanced;
  	private boolean resizable;
  	private int minTitleFontSize = 0;
  	private int maxTitleFontSize = Integer.MAX_VALUE;
  	private boolean titleVisible;
  	private int layoutOrientation = DYNAMIC_LAYOUT;
  
  	/**
  	 * Constructs AbstractDisplayerPanel already containing the
  	 * <code>valueComponent</code>.
  	 */
  	public AbstractDisplayerPanel()
  	{
  		this(null, false, DYNAMIC_LAYOUT, true, true, true, 1, Integer.MAX_VALUE);
  	}
  
 	/**
 	 * Constructs AbstractDisplayerPanel already containing the
 	 * <code>valueComponent</code> with inital values. It is cheap to set
 	 * values now, since component is not in AWT containment.
 	 *
 	 * @param title initial value
 	 * @param titleVisible initial value
 	 * @param layoutOrientation initial value
 	 * @param resizable initial value
 	 * @param enabled initial value
 	 * @param enchanced initial value
 	 * @param minTitleFontSize initial value
 	 * @param maxTitleFontSize initial value
 	 */
 	public AbstractDisplayerPanel(String title, boolean titleVisible,
 	    int layoutOrientation, boolean resizable, boolean enabled,
 	    boolean enchanced, int minTitleFontSize, int maxTitleFontSize)
 	{
 		super();
 
 		setBackground(ColorHelper.getCosyControl());
 		setBorder(new CosyUIElements.PanelFlushBorder());
 		setPreferredSize(new Dimension(200, 50));
 		setMinimumSize(new Dimension(200, 50));
 		setLayout(new GridBagLayout());
 
 		//RT#4567 fix
 		addComponentListener(new ComponentAdapter() {
 				public void componentResized(ComponentEvent e)
 				{
 					layoutDisplayer();
 				}
 			});
 
 		//end fix
 		setTitle(title);
 		setTitleVisible(titleVisible);
 		setLayoutOrientation(layoutOrientation);
 		setResizable(resizable);
 		setEnabled(enabled);
 		setEnhanced(enchanced);
 		setTitleMinimumFontSize(minTitleFontSize);
 		setTitleMaximumFontSize(maxTitleFontSize);
 		setPopupEnabled(true);
 	}
 
 	/**
 	 * Loads the default
 	 * <code>com.cosylab.gui.components.customizer.Customizer</code> for this
 	 * displayer and returns it.
 	 *
 	 * @return the Customizer intance for this displayer
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 
 		return customizer;
 	}
 
 	/**
 	 * Overriden to disable subcomponents.
 	 *
 	 * @param enabled if the component is to be enabled
 	 */
 	public void setEnabled(boolean enabled)
 	{
 		if (enabled == isEnabled()) {
 			return;
 		}
 
 		super.setEnabled(enabled);
 		internalSetEnabled();
 	}
 
 	/**
 	 * Sets the enhanced property of the displayer panel
 	 *
 	 * @param b whether to render in enhanced mode
 	 */
 	public void setEnhanced(boolean b)
 	{
 		if (enhanced == b) {
 			return;
 		}
 
 		enhanced = b;
 		internalSetEnhanced();
 		firePropertyChange("enhanced", !b, b);
 	}
 
 	/**
 	 * Determines whether the displayer panel is to be rendered enhanced.
 	 *
 	 * @return true if diaplayer panel is enhanced
 	 */
 	public boolean isEnhanced()
 	{
 		return enhanced;
 	}
 
 	/**
 	 * Sets the orientation tag determining how the title and value components
 	 * should be layed out inside the panel.
 	 *
 	 * @param i layout tag, valid values are <code>HORIZONTAL_LAYOUT</code>,
 	 *        <code>VERTICAL_LAYOUT</code>, <code>DYNAMIC_LAYOUT</code>
 	 *
 	 * @throws IllegalArgumentException if no applicable parameter is supplied
 	 *
 	 * @see #getLayoutOrientation()
 	 */
 	public void setLayoutOrientation(int i)
 	{
 		if (i == layoutOrientation) {
 			return;
 		}
 
 		if (i != HORIZONTAL_LAYOUT && i != VERTICAL_LAYOUT
 		    && i != DYNAMIC_LAYOUT) {
 			throw new IllegalArgumentException();
 		}
 
 		int oldVal = layoutOrientation;
 
 		layoutOrientation = i;
 
 		if (i == DYNAMIC_LAYOUT) {
 			addComponentListener(getResizeListener());
 		} else if (oldVal == DYNAMIC_LAYOUT) {
 			removeComponentListener(getResizeListener());
 		}
 
 		layoutDisplayer();
 		firePropertyChange("layoutOrientation", oldVal, i);
 	}
 
 	/**
 	 * <p>
 	 * Returns the current layout orientation setting.
 	 * </p>
 	 * 
 	 * <p>
 	 * Possible values are:
 	 * 
 	 * <ul>
 	 * <li>
 	 * <code>#HORIZONTAL_LAYOUT</code> - the title and value components are
 	 * displayed side by side horizontally
 	 * </li>
 	 * <li>
 	 * <code>#VERTICAL_LAYOUT</code> - the title and value components are
 	 * displayed vertically, title above the value
 	 * </li>
 	 * <li>
 	 * <code>#DYNAMIC_LAYOUT</code> - the orientation of the components inside
 	 * the panel is determined dynamically on the basisi of the components
 	 * preferred sizes so as to most affectivelly fill up the space available.
 	 * </li>
 	 * </ul>
 	 * </p>
 	 *
 	 * @return int
 	 */
 	public int getLayoutOrientation()
 	{
 		return layoutOrientation;
 	}
 
 	/**
 	 * Returns popum manager for adding popup actions.
 	 *
 	 * @see com.cosylab.gui.components.util.PopupManageable#getPopupManager()
 	 */
 	public PopupManager getPopupManager()
 	{
 		if (popupManager == null) {
 			popupManager = new PopupManager(this, false);
 			popupManager.addAction(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 					public void actionPerformed(ActionEvent e)
 					{
 						getCustomizer().showDialog();
 					}
 				});
 			popupManager.addAction(new AbstractAction("Capture screen..."){
 				private static final long serialVersionUID = 1L;
 
 				public void actionPerformed(ActionEvent e){
 				   	ScreenCapturer sc = new ScreenCapturer(AbstractDisplayerPanel.this);
 					sc.showScreenDialog();
 				   }
 			});
 		}
 
 		return popupManager;
 	}
 	
 	/**
 	 * Return true if the popup menu is enabled or false otherwise.
 	 * 
 	 * @return true if popup is enabled
 	 */
 	public boolean isPopupEnabled() {
 		return popupEnabled;
 	}
 	
 	/**
 	 * Enables or disables the popup menu.
 	 * 
 	 * @param enabled true if enable or false if disableds
 	 */
 	public void setPopupEnabled(boolean enabled) {
 		if (popupEnabled == enabled) return;
 		popupEnabled = enabled;
 		if (enabled) {
 			getValueComponent().addMouseListener(getPopupManager().getMouseHook());
 			addMouseListener(getPopupManager().getMouseHook());
 			getTitleComponent().addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			getValueComponent().removeMouseListener(getPopupManager().getMouseHook());
 			removeMouseListener(getPopupManager().getMouseHook());
 			getTitleComponent().removeMouseListener(getPopupManager().getMouseHook());
 		}		
 		firePropertyChange("popupEnabled",!popupEnabled,popupEnabled);
 	}
 
 	/**
 	 * Sets the resizability of the title and value components of the panel.
 	 *
 	 * @param b wether the title and value components should adjust their sizes
 	 *        in accord with the size of the panel.
 	 *
 	 * @see #isResizable()
 	 */
 	public void setResizable(boolean b)
 	{
 		if (resizable == b) {
 			return;
 		}
 
 		resizable = b;
 		internalSetResizable();
 		layoutDisplayer();
 		firePropertyChange("resizable", !b, b);
 	}
 
 	/**
 	 * <p>
 	 * Determines wether the components inside the panel should resize together
 	 * with the panel or should maintain their preferred sizes.
 	 * </p>
 	 * 
 	 * <p>
 	 * When disabled, the size of the components inside the panel is determined
 	 * according to the <i>preferred size</i> of the panel.
 	 * </p>
 	 *
 	 * @return <code>true</code> if the title and value components resize
 	 *         accordingly with the size of the panel, <code>false</code>
 	 *         otherwise.
 	 */
 	public boolean isResizable()
 	{
 		return resizable;
 	}
 
 	/**
 	 * Sets the state to the component.
 	 *
 	 * @param state to set.
 	 *
 	 * @see com.cosylab.application.state.StateOriginator#setState(com.cosylab.application.state.State)
 	 */
 	public void setState(State state)
 	{
 		setTitle(state.getString("title", getTitle()));
 		setResizable(state.getBoolean("resizable", isResizable()));
 		setTitleVisible(state.getBoolean("titleVisible", isTitleVisible()));
 		setLayoutOrientation(state.getInt("layoutOrientation",
 		        getLayoutOrientation()));
 	}
 
 	/**
 	 * Returns the current state of the component.
 	 *
 	 * @return current state.
 	 *
 	 * @see com.cosylab.application.state.StateOriginator#getState()
 	 */
 	public State getState()
 	{
 		State state = StateFactory.createState();
 
 		state.putBoolean("resizable", isResizable());
 		state.putString("title", getTitle());
 		state.putBoolean("titleVisible", isTitleVisible());
 		state.putInt("layoutOrientation", getLayoutOrientation());
 
 		return state;
 	}
 
 	/**
 	 * Sets the title to be displayed beside the value component.
 	 *
 	 * @param value title String to be displayed
 	 */
 	public void setTitle(String value)
 	{
 		String oldVal = title;
 		title = value;
 		internalSetTitle();
 		layoutDisplayer();
 		firePropertyChange("title", oldVal, value);
 	}
 
 	/**
 	 * Returns the title displayed beside the value component.
 	 *
 	 * @return title displayed
 	 */
 	public String getTitle()
 	{
 		return title;
 	}
 
 	/**
 	 * Adds or removes the Title displayed beside the value component.
 	 *
 	 * @param b wether the title should be displayed or not.
 	 */
 	public void setTitleVisible(boolean b)
 	{
 		if (b == titleVisible) {
 			return;
 		}
 
 		titleVisible = b;
 		layoutDisplayer();
 		firePropertyChange("titleVisible", !b, b);
 	}
 
 	/**
 	 * Determines wether the title of this component is displayed beside the
 	 * value component.
 	 *
 	 * @return <code>true</code> if the title is displayed and
 	 *         <code>false</code> if not.
 	 */
 	public boolean isTitleVisible()
 	{
 		return titleVisible;
 	}
 
 	private ComponentListener getResizeListener()
 	{
 		if (resizeListener == null) {
 			resizeListener = new ComponentAdapter() {
 						public void componentResized(ComponentEvent e)
 						{
 							layoutDisplayer();
 						}
 					};
 		}
 
 		return resizeListener;
 	}
 
 	/**
 	 * Returns the component to display the title of thi displayer. This method
 	 * is used by the <code>#DisplayerLayout</code>.
 	 *
 	 * @return component displaying the title
 	 */
 	protected JLabel getTitleComponent()
 	{
 		if (titleLabel == null) {
 			titleLabel = new ResizableTextLabel();
 			titleLabel.setHorizontalAlignment(JLabel.CENTER);
 			titleLabel.setEnabled(isEnabled());
 			titleLabel.setEnhanced(isEnhanced());
 			titleLabel.setResizable(isResizable());
 			titleLabel.setMaximumFontSize(maxTitleFontSize);
 			titleLabel.setMinimumFontSize(minTitleFontSize);
 			internalSetTitle();
 		}
 
 		return titleLabel;
 	}
 
 	/**
 	 * Should return the component to display the value of this displayer. This
 	 * method is called inside the constructor to add the
 	 * <code>valueComponent</code> to the AbstractDisplayerPanel. Subclasses
 	 * should thus use lazy initialization inside  this method.
 	 *
 	 * @return the value component of the AbstractDisplayerPanel.
 	 */
 	protected abstract JComponent getValueComponent();
 
 	protected void internalSetEnabled()
 	{
 		if (titleLabel != null) {
 			titleLabel.setEnabled(isEnabled());
 		}
 	}
 
 	protected void internalSetEnhanced()
 	{
 		if (titleLabel != null) {
 			titleLabel.setEnhanced(isEnhanced());
 		}
 	}
 
 	protected void internalSetResizable()
 	{
 		if (titleLabel != null) {
 			titleLabel.setResizable(isResizable());
 		}
 	}
 
 	protected void internalSetTitle()
 	{
 		if (titleLabel == null) {
 			return;
 		}
 
 		String value = title;
 
 		if (value == null && Beans.isDesignTime()) {
 			value = "<title>";
 		}
 
 		//if (value == null) {
 		//	value = "";
 		//}
 		titleLabel.setText(value);
 	}
 
 	/**
 	 * Lays out the displayer according to the set layout orientation.
 	 */
 	protected void layoutDisplayer()
 	{
 		if (isTitleVisible() && getTitle() != null && getTitle().length() > 0) {
 			//if (getTitleComponent().getParent()!=this) {
 				layoutValueAndTitle();
 			//}
 		} else {
 			//if (getTitleComponent().getParent()==this) {
 				layoutValue();
 			//}
 		}
 	}
 
 	protected void layoutValue()
 	{
 		removeAll();
 		Insets insets = new Insets(getSize().height * 3 / 100,
 			    getSize().width * 3 / 100, getSize().height * 3 / 100,
 			    getSize().width * 3 / 100);
 		int fill = (isResizable() ? GridBagConstraints.BOTH
 			: GridBagConstraints.NONE);
 
 		add(getValueComponent(),
 		    new GridBagConstraints(1, 1, 1, 1, 1, 1, GridBagConstraints.CENTER,
 		        fill, insets, 0, 0));
 	}
 
 	protected void layoutValueAndTitle()
 	{
 		removeAll();
 	
 		Insets insets = !isResizable() ? new Insets(2, 2, 2, 2)
 			: new Insets(getSize().height * 3 / 100, getSize().width * 3 / 100,
 			    getSize().height * 3 / 100, getSize().width * 3 / 100);
 
 		//		Insets insets = new Insets(2, 2, 2, 2);
 		int fill = (isResizable() ? GridBagConstraints.BOTH
 			: GridBagConstraints.NONE);
 		double w = isResizable() ? 1.0 : 0.0;
 	
 
 		if (1. * (getSize().height) / (getTitleComponent().getPreferredSize().height
 		    + getValueComponent().getPreferredSize().height) > 1. * (getSize().width) / (getTitleComponent()
 		    .getPreferredSize().width
 		    + getValueComponent().getPreferredSize().width)
 		    && getLayoutOrientation() == AbstractDisplayerPanel.DYNAMIC_LAYOUT
 		    || getLayoutOrientation() == AbstractDisplayerPanel.VERTICAL_LAYOUT) {
 			add(getTitleComponent(),
 			    new GridBagConstraints(1, 1, 1, 1, w, w,
 			        GridBagConstraints.CENTER, fill, insets, 0, 0));
 			add(getValueComponent(),
 			    new GridBagConstraints(1, 2, 1, 1, w, w * 1.2,
 			        GridBagConstraints.CENTER, fill, insets, 0, 0));			
 		} else {
 			add(getTitleComponent(),
 			    new GridBagConstraints(1, 1, 1, 1, w, w,
 			        GridBagConstraints.EAST, fill, insets, 0, 0));
 			add(getValueComponent(),
 			    new GridBagConstraints(2, 1, 1, 1, w * 1.2, w,
 			        GridBagConstraints.WEST, fill, insets, 0, 0));
 		}
 	}
 
 	/**
 	 * Returns the maximum font size allowed.
 	 *
 	 * @return
 	 */
 	public int getTitleMaximumFontSize()
 	{
 		return maxTitleFontSize;
 	}
 
 	/**
 	 * Returns the minimum font size allowed.
 	 *
 	 * @return
 	 */
 	public int getTitleMinimumFontSize()
 	{
 		return minTitleFontSize;
 	}
 
 	/**
 	 * Sets the maximum title font size allowed.
 	 *
 	 * @param max
 	 */
 	public void setTitleMaximumFontSize(int max)
 	{
 		if (max == maxTitleFontSize) {
 			return;
 		}
 
 		int oldValue = maxTitleFontSize;
 		maxTitleFontSize = max;
 		layoutDisplayer();
 		if (titleLabel!=null) titleLabel.setMaximumFontSize(maxTitleFontSize);
 		firePropertyChange(AbstractDisplayerPanelCustomizer.MAX_TITLE_FONT_SIZE,
 		    oldValue, max);
 	}
 
 	/**
 	 * Sets the minimum title font size allowed.
 	 *
 	 * @param min
 	 */
 	public void setTitleMinimumFontSize(int min)
 	{
 		if (min == minTitleFontSize) {
 			return;
 		}
 
 		int oldValue = minTitleFontSize;
 		minTitleFontSize = min;
 		layoutDisplayer();
 		if (titleLabel!=null) titleLabel.setMinimumFontSize(minTitleFontSize);
 		firePropertyChange(AbstractDisplayerPanelCustomizer.MIN_TITLE_FONT_SIZE,
 		    oldValue, min);
 	}
 	
     /* (non-Javadoc)
      * @see javax.swing.JComponent#setTransferHandler(javax.swing.TransferHandler)
      */
     @Override
     public void setTransferHandler(TransferHandler newHandler) {
     	super.setTransferHandler(newHandler);
     	CosyTransferHandler.registerTransferHandler(this,newHandler,new JComponent[]{getTitleComponent()});
     }
 
     /**
 	 * Enables/disables mouse dragging. Dragging can only be enabled if
 	 * this component uses CosyTransferHandler.
 	 * 
 	 * @param enabled
 	 */
     public void setDragEnabled(boolean enabled) {
     	if (isDragEnabled() == enabled) return;
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			if (((CosyTransferHandler)getTransferHandler()).isExportEnabled() == enabled) return;
 			
 			((CosyTransferHandler)getTransferHandler()).setExportEnabled(enabled, this);
 		}
 		firePropertyChange("dragEnabled", !enabled, enabled);
 	}
 	
     /**
 	 * Returns true if drag is enabled.
 	 * 
 	 * @return true if drag is enabled
 	 */
 	public boolean isDragEnabled() {
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			return ((CosyTransferHandler)getTransferHandler()).isExportEnabled();
 		} else {
 			return getTransferHandler() != null;
 		}
 	}
 	
 	/**
 	 * Enable/disable the mouse drop. Drop can only be enabled if this component uses
 	 * CosyTransferHandler.
 	 * 
 	 * @param enabled
 	 */
 	public void setDropEnabled(boolean enabled) {
 		if (isDropEnabled() == enabled) return;
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			if (((CosyTransferHandler)getTransferHandler()).isReceiveEnabled() == enabled) return;
 			
 			((CosyTransferHandler)getTransferHandler()).setReceiveEnabled(enabled, this);
 		}
 		
 		firePropertyChange("dropEnabled", !enabled, enabled);
 	}
 	
 	/**
 	 * Returns true if drop is enabled.
 	 * 
 	 * @return true if drop is enabled
 	 */
 	public boolean isDropEnabled() {
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			return ((CosyTransferHandler)getTransferHandler()).isReceiveEnabled();
 		} else {
 			return getTransferHandler() != null;
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setBackground(java.awt.Color)
 	 */
 	@Override
 	public void setBackground(Color bg) {
 		super.setBackground(bg);
 		getValueComponent().setBackground(bg);
 		getTitleComponent().setBackground(bg);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setForeground(java.awt.Color)
 	 */
 	@Override
 	public void setForeground(Color fg) {
 		super.setForeground(fg);
 		getValueComponent().setForeground(fg);
 		getTitleComponent().setForeground(fg);
 	}
 
 
 }
 
 /* __oOo__ */