/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans.
    *
    * CosyBeans 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 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.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.Image;
  import java.awt.event.ActionEvent;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.io.File;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javax.swing.AbstractAction;
  import javax.swing.Icon;
  import javax.swing.ImageIcon;
  import javax.swing.JLabel;
  import javax.swing.SwingConstants;
  
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.IconHelper;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.RunnerHelper;
  import com.cosylab.gui.displayers.AbstractDisplayerPanel;
  import com.cosylab.gui.displayers.CommonDisplayer;
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.LongConsumerMulticaster;
  import com.cosylab.gui.util.UserSettingsProtection;
  import com.cosylab.util.CommonException;
  
  /** 
   * <code>IconDisplayer</code> is a displayer that displays icons associated with
   * different values. 
   * 
   * 
   * @author Jaka Bobnar, Cosylab
   * 
   */
  public class IconDisplayer extends AbstractDisplayerPanel implements
          com.cosylab.gui.displayers.IconDisplayer {
  	
  	public static final String ICONS_PROPERTY = "icons";
  	public static final String DEFAULT_ICON_PROPERTY = "defaultIcon";
  	public static final String DEFAULT_ICON_NAME_PROPERTY = "defaultIconName";
  
  	private static final long serialVersionUID = 1L;
  
  	private JLabel label;
  
  	private Icon defaultIcon;
  	private String defaultIconName;
  	private long value;
  	private PopupManager popupManager;
  	private InfoDialog infoDialog;
  	private boolean keepRatio = false;
  	private boolean scaleIcons = false;
  	
  	private Map<Long, ValueIconPair> valueIcons;
  
  	/**
       * Creates new IconDisplayer.
       */
  	public IconDisplayer() {
  		super();
  		initialize();
  	}
  
  	/**
       * Creates new IconDisplayer and defines the default icon.
       * 
       * @param defaultIcon
       *        Default icon to set.
       */
  	public IconDisplayer(Icon defaultIcon) {
  		super();
  		this.defaultIcon=defaultIcon;
  		defaultIconName = defaultIcon.toString();
  		initialize();
  	}
 
 	/**
      * Creates new IconDisplayer and new default icon. This constructor will
      * create a new icon from the given path. The path has to be in the classpath
      * of the project for the icon to be generated. If the path points to an explicit
      * file in the local system the icon displayer will generate the icon, but will
      * fail if the file does not exist. 
      * 
      * @param defaultIcon the name of default icon in classpath to use
      */
 	public IconDisplayer(String defaultIcon) {
 		this(IconHelper.createIcon(defaultIcon));
 		defaultIconName = defaultIcon;
 	}
 	
 	/**
 	 * Creates a new IconDisplayer with the default icon loaded from a given file.
 	 * This file does not need to be in the classpath of the project.
 	 * 
 	 * @param file the icon image file
 	 */
 	public IconDisplayer(File file) {
 		this(IconHelper.createIcon(file));
 		defaultIconName = file.getAbsolutePath();
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#getLoadedIcons()
 	 */
 	public ValueIconPair[] getIcons() {
 		ValueIconPair[] icons = new ValueIconPair[valueIcons.size()];
 		Iterator<ValueIconPair> it = valueIcons.values().iterator();
 		int i = 0;
 		while (it.hasNext()) {
 			icons[i] = it.next();
 			i++;
 		}
 		return icons;
 	
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#setLoadedIcons(java.util.Map)
 	 */
 	public void setIcons(ValueIconPair[] icons) {
    		ValueIconPair[] old = getIcons();
 		valueIcons.clear();
 		for (ValueIconPair pair : icons) {
 			valueIcons.put(pair.getValue(), pair);
 		}
 		firePropertyChange(ICONS_PROPERTY, old, getIcons());
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#addIcons(java.util.Map)
 	 */
 	public void addIcons(ValueIconPair[] icons) {
 		ValueIconPair[] old = getIcons();
 		for (ValueIconPair pair : icons) {
 			valueIcons.put(pair.getValue(), pair);
 		}       
 		firePropertyChange(ICONS_PROPERTY, old, getIcons());
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#removeIcons(com.cosylab.gui.IconValuepair[])
 	 */
 	public void removeIcons(ValueIconPair[] icons) {
 		ValueIconPair[] old = getIcons();
 		for (ValueIconPair pair : icons) {
 			valueIcons.remove(pair.getValue());
 		}   
 		firePropertyChange(ICONS_PROPERTY, old, getIcons());
 		
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#removeIcon(com.cosylab.gui.IconValuepair)
 	 */
 	public void removeIcon(ValueIconPair icon) {
 		ValueIconPair[] old = getIcons();
 		valueIcons.remove(icon.getValue());
 		firePropertyChange(ICONS_PROPERTY, old, getIcons());
 	}
 	 
 	/**
 	 * Adds an icon. This method is the same as {@link #addIcon(ValueIconPair)} using
 	 * the new {@link ValueIconPair}(value, icon).
 	 * 
 	 * @param value
 	 * @param icon
 	 */
 	public void addIcon(long value, Icon icon) {
 		addIcon(new ValueIconPair(value,icon));
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#addIcon(com.cosylab.gui.ValueIconPair)
 	 */
 	public void addIcon(ValueIconPair pair) {
 		ValueIconPair[] old = getIcons();
 		valueIcons.put(pair.getValue(), pair);
 		firePropertyChange(ICONS_PROPERTY, old, getIcons());
 	}
 	
 	/**
      * Preforms GUI initialization.
      */
 	private void initialize() {
 
 		setLayout(new BorderLayout());
 		add(getTitleLabel(), BorderLayout.NORTH);
 
 		
 		add(getLabel(), BorderLayout.CENTER);
 		
 		Dimension size = new Dimension(50, 50);
 		setPreferredSize(size);
 		setSize(size); 
 		setBackground(ColorHelper.getCosyControl());
 		getLabel().setIcon(getDefaultIcon());
 		valueIcons = new HashMap<Long, ValueIconPair>();
 		
 		setTitleVisible(false);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.AbstractDisplayerPanel#setBackground(java.awt.Color)
 	 */
 	@Override
 	public void setBackground(Color bg) {
 		super.setBackground(bg);
 		getLabel().setBackground(bg);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.AbstractDisplayerPanel#setForeground(java.awt.Color)
 	 */
 	@Override
 	public void setForeground(Color fg) {
 		super.setForeground(fg);
 		getLabel().setForeground(fg);
 	}
 	
 	private JLabel getLabel() {
 		if (label == null) {
 			label = new JLabel();
 			label.setHorizontalAlignment(SwingConstants.CENTER);
 			label.setVerticalAlignment(SwingConstants.CENTER);
 			label.addComponentListener(new ComponentAdapter() {
 			
 				@Override
 				public void componentResized(ComponentEvent e) {
 					updateIcon();
 				}
 			
 			});
 		}
 		return label;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#setValue(long)
 	 */
 	public void setValue(long value) {
 		this.value = value;
 		updateIcon();
 	}
 	
 	protected void updateIcon() {
 		Icon icon = null;
 		if (valueIcons.get(value) != null) {
 			icon = valueIcons.get(value).getIcon();
 		} else {
 			icon = getDefaultIcon();
 		}
 		
 		if (icon instanceof ImageIcon && scaleIcons) {
 			if (keepRatio) {
 				label.setIcon(IconCustomizer.getScaledIcon((ImageIcon)icon, getHeight(), getWidth()));
 			} else {
 				label.setIcon(new ImageIcon(((ImageIcon)icon).getImage().
 						getScaledInstance(getWidth(), getHeight(), Image.SCALE_FAST)));
 			}
 		} else {
 			label.setIcon(icon);
 		}
 
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.IconDisplayer#getValue()
 	 */
 	public long getValue() {
 		return value;
 	}
 
 	/**
      * Creates and sets default icon from file name. Default icon will be used
      * when no condition is met. The given filename should point to a file inside
      * the classpath of the project.
      * 
      * @param filename
      */
 	public void setDefaultIconName(String filename) {
 		if (filename != null && filename.equals(defaultIconName) || (filename == null && defaultIconName == null)) 
 			return;
 		String old = defaultIconName;
 		setDefaultIcon(IconHelper.createIcon(filename));
 		defaultIconName = filename;
 		firePropertyChange(DEFAULT_ICON_NAME_PROPERTY, old, defaultIconName);
 	}
 	
 	/**
 	 * Creates and sets default icon from the given file. The file can point to
 	 * any location on the computer as long as it is accessible by the current user's
 	 * rights.
 	 * 
 	 * @param file the image file
 	 */
 	public void setDefaultIcon(File file) {
 		if (file != null && file.getAbsolutePath().equals(defaultIconName) || 
 				(file == null && defaultIconName == null)) 
 			return;
 		String old = defaultIconName;
 		setDefaultIcon(IconHelper.createIcon(file));
 		if (file != null) {
 			defaultIconName = file.getAbsolutePath();
 		}
 		firePropertyChange(DEFAULT_ICON_NAME_PROPERTY, old, defaultIconName);
 	}
 
 	/**
      * Sets default icon. Default icon will be used when no condition is met.
      * 
      * @param newIcon
      *        New icon to use. May be null.
      */
 	public void setDefaultIcon(Icon newIcon) {
 		Icon old = defaultIcon;
 		defaultIcon = newIcon;
 		updateIcon();
 		if (defaultIcon != null)
 			defaultIconName = defaultIcon.toString();
 		else 
 			defaultIconName = null;
 		firePropertyChange(DEFAULT_ICON_PROPERTY, old, this.defaultIcon);
 	}
 	
 	/**
 	 * Returns the path to the default icon.
 	 * 
 	 * @return
 	 */
 	public String getDefaultIconName() {
 		return defaultIconName;
 	}
 
 	/**
      * Returns default icon. Default icon is used when no condition is met.
      * 
      * @return Instance of default icon or null.
      */
 	public Icon getDefaultIcon() {
 //		if (defaultIcon==null) {
 //			defaultIcon= new Icon() {
 //			
 //				public int getIconHeight() {
 //					return 32;
 //				}
 //			
 //				public int getIconWidth() {
 //					return 32;
 //				}
 //			
 //				public void paintIcon(Component c, Graphics g, int x, int y) {
 //					PaintHelper.paintDisabled(g,4,4,g.getClipBounds().width-8,g.getClipBounds().height-8);
 //				}
 //			
 //			};
 //		}
 		return defaultIcon;
 	}
 
 	/*
      * (non-Javadoc)
      * 
      * @see com.cosylab.gui.displayers.Displayer#isEditable()
      */
 	public boolean isEditable() {
 		return false;
 	}
 
 	/*
      * (non-Javadoc)
      * 
      * @see com.cosylab.gui.displayers.LongConsumer#updateValue(long, long)
      */
 	public void updateValue(long timestamp, long value) throws CommonException {
 		setValue(value);
 	}
 
 	/*
      * (non-Javadoc)
      * 
      * @see com.cosylab.gui.displayers.DataConsumer#setCharacteristics(java.util.Map)
      */
 	public void setCharacteristics(Map characteristics) {
 		suspend();
 		Object o = characteristics.get(CommonDisplayer.C_DISPLAY_NAME);
 
 		if (o != null) {
 			try {
 				UserSettingsProtection.setUnprotected(this,"title",o.toString());
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 		resume();
 	}
 
 	/*
      * (non-Javadoc)
      * 
      * @see com.cosylab.gui.displayers.DataConsumer#getSupportedConsumerTypes()
      */
 	@SuppressWarnings("unchecked")
 	public Class[] getSupportedConsumerTypes() {
 		return LongConsumerMulticaster.SUPPORTED_CONSUMER_TYPES;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDataConsumer(java.lang.Class)
 	 */
 	@SuppressWarnings("unchecked")
 	public <D extends DataConsumer> D getDataConsumer(Class<D> type) {
 		return (D) LongConsumerMulticaster.createDataConsumer(type, this);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.AbstractDisplayerPanel#cleanup()
 	 */
 	public void cleanup()
 	{
 		super.cleanup();
 		valueIcons.clear();
 	}
 	
 	/**
 	 * Returns the InfoDialog for this displayer.
 	 * 
 	 * @return
 	 */
 	public InfoDialog getInfoDialog() {
 		if (infoDialog == null) {
 			infoDialog = new InfoDialog(this);
 		}
 		return infoDialog;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.AbstractDisplayerPanel#getPopupManager()
 	 */
 	public PopupManager getPopupManager()
 	{
 		if (popupManager == null) {
 			popupManager = super.getPopupManager();
 			popupManager.addAction(new AbstractAction("Info...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						getInfoDialog().setVisible(true);
 					}
 				});
 		}
 		
 		return popupManager;
 	}
 	
 	/**
 	 * Returns true if icons aspect ratio is kept when the icon is scaled to fit 
 	 * the component size or false if displayer's aspect ratio is used.
 	 * 
 	 * @return true if icons are scaled
 	 */
 	public boolean isKeepRatio() {
 		return keepRatio;
 	}
 	
 	/**
 	 * Sets whether the icons should keep the aspect ratio if it is scale
 	 * to fit the component;
 	 * 
 	 * @param keepRatio true if aspect ratio of the icons is kept
 	 */
 	public void setKeepRatio(boolean keepRatio) {
 		boolean old= this.keepRatio;
 		this.keepRatio = keepRatio;
 		setValue(getValue());
 		firePropertyChange("keepRatio",old,keepRatio);
 	}
 	/**
 	 * Sets whether the icons should be scale to fit the size of the component.
 	 * 
 	 * @param scale true if icons are scaled to fit 
 	 */
 	public void setScaleIcons(boolean scale) {
 		boolean old = scaleIcons;
 		this.scaleIcons = scale;
 		setValue(getValue());
 		firePropertyChange("scaleIcons", old, scaleIcons);
 	}
 	
 	/**
 	 * Returns true if icons are scaled to fit the size of the component.
 	 * 
 	 * @return
 	 */
 	public boolean isScaleIcons() {
 		return scaleIcons;
 	}
 	
 	public static void main(String[] args) {
 
 		final IconDisplayer id = new IconDisplayer();
 		id.setPopupEnabled(false);
 		ValueIconPair[] icons = new ValueIconPair[]{
 		new ValueIconPair(0L, IconHelper.createIcon("icons/navigation/ArrowLeftLeft16.gif")),
 		        new ValueIconPair(1L, IconHelper.createIcon("icons/navigation/ArrowLeft16.gif")),
 		        new ValueIconPair(2L, IconHelper.createIcon("icons/navigation/ArrowRight16.gif")),
 		        new ValueIconPair(3L, IconHelper.createIcon("icons/navigation/ArrowRightRight16.gif"))
 		};
 		id.setIcons(icons);
 		
 		Thread th = new Thread(new Runnable(){
 			public void run() {
 				try {
 					int i = 0;
 
 					while (true) {
 						id.setValue(i);
 						i = (i + 1) % 5;
 						Thread.sleep(5000);
 					}
 				} catch (InterruptedException e) {
 				}				
 			}
 		});
 		id.setTitle("Demo");
 		RunnerHelper.runComponent(id, 300,300);
 		th.start();
 	}
 }
 
 /* __oOo__ */